Att skapa en medlemskapsbaserad webbplats verkar till en början vara en skrämmande uppgift. Om du någonsin velat göra detta själv, då bara gav upp när du började fundera på hur du ska sätta ihop det med dina PHP-kunskaper, då är den här artikeln för dig. Vi kommer att gå igenom alla aspekter av att skapa en medlemskapsbaserad webbplats, med ett säkert medlemsområde skyddat med lösenord.

Hela processen består av två stora delar: användarregistrering och användarautentisering. I den första delen kommer vi att täcka skapandet av anmälningsblankett och lagra data i en MySQL-databas. I den andra delen kommer vi att skapa inloggningsformuläret och använda det för att ge användare åtkomst i det säkra området.

Ladda ner koden

Du kan ladda ner hela källkoden för registrerings-/inloggningssystemet från länken nedan:

Konfiguration och uppladdning
ReadMe-filen innehåller detaljerade instruktioner.

Öppna source\include\membersite_config.php fil i en textredigerare och uppdatera konfigurationen. (Databasinloggning, din webbplats namn, din e-postadress etc).

Ladda upp hela katalogens innehåll. Testa register.php genom att skicka in formuläret.

Anmälningsformuläret

För att skapa ett användarkonto behöver vi samla in en minimal mängd information från användaren. Vi behöver hans namn, hans e-postadress och hans önskade användarnamn och lösenord. Naturligtvis kan vi be om mer information vid det här laget, men en lång blankett är alltid en avstängning. Så låt oss begränsa oss till just dessa områden.

Här är anmälningsformuläret:

Registrera

Ditt fullständiga namn*: E-postadress*: Användarnamn*: Lösenord*:

Så vi har textfält för namn, e-post och lösenord. Observera att vi använder för bättre användbarhet.

Form validering

Vid det här laget är det en bra idé att sätta in någon form valideringskod på plats, så att vi ser till att vi har all information som krävs för att skapa användarkontot. Vi måste kontrollera om namn och e-postadress samt lösenord är ifyllda och att e-postmeddelandet är i rätt format.

Hantera formulärinlämningen

Nu måste vi hantera formulärdata som lämnas in.

Här är sekvensen (se filen fg_membersite.php i den nedladdade källan):

funktion RegisterUser() ( if(!isset($_POST["submitted"])) (retur false; ) $formvars = array(); if(!$this->ValidateRegistrationSubmission()) (retur false; ) $this- >CollectRegistrationSubmission($formvars); if(!$this->SaveToDatabase($formvars)) ( return false; ) if(!$this->SendUserConfirmationEmail($formvars)) (retur false; ) $this->SendAdminIntimationEmail($ formvars); return true;

Först validerar vi inlämningen av formuläret. Sedan samlar vi in ​​och "sanerar" formulärinlämningsdata (gör alltid detta innan du skickar e-post, sparar i databasen etc). Forminlämningen sparas sedan i databastabellen. Vi skickar ett e-postmeddelande till användaren och begär bekräftelse. Sedan informerar vi administratören om att en användare har registrerat sig.

Spara data i databasen

Nu när vi samlat in all data måste vi lagra den i databasen.
Så här sparar vi formuläret i databasen.

funktion SaveToDatabase(&$formvars) (if(!$this->DBLogin()) ( $this->HandleError("Databasinloggning misslyckades!"); return false; ) if(!$this->Ensuretable()) ( return false; ) if(!$this->IsFieldUnique($formvars,"e-post")) ( $this->HandleError("Detta e-postmeddelande är redan registrerat"); return false; ) if(!$this->IsFieldUnique( $formvars,"användarnamn")) ( $this->HandleError("Detta användarnamn används redan. Försök med ett annat användarnamn"); return false; ) if(!$this->InsertIntoDB($formvars)) ( $this- >HandleError("Infogning i databasen misslyckades!" return false;

Observera att du har konfigurerat databasinloggningsdetaljerna i filen membersite_config.php. I de flesta fall kan du använda "localhost" för databasvärd.
Efter att ha loggat in ser vi till att tabellen finns.(Om inte kommer skriptet att skapa den önskade tabellen).
Då ser vi till att användarnamnet och e-postadressen är unika. Om det inte är unikt returnerar vi felet tillbaka till användaren.

Databastabellstrukturen

Detta är tabellstrukturen. Funktionen CreateTable() i filen fg_membersite.php skapar tabellen. Här är koden:

function CreateTable() ( $qry = "Skapa tabell $this->tablename (". "id_user INT NOT NULL AUTO_INCREMENT ," "namn VARCHAR(128) NOT NULL ," "e-posta VARCHAR(64) NOT NULL ," " "telefonnummer VARCHAR(16) NOT NULL ," "användarnamn VARCHAR(16) NOT NULL ," "lösenord VARCHAR(32) NOT NULL ," "bekräftakod VARCHAR(32) ," " ")" if(!mysql_query($qry,$ this->connection)) ( $this->HandleDBError("Fel vid skapande av tabellen \nfrågan var\n $qry"); return false; ) return true )

Fältet id_user kommer att innehålla användarens unika ID och är också den primära nyckeln i tabellen. Observera att vi tillåter 32 tecken för lösenordsfältet. Vi gör detta eftersom vi, som en extra säkerhetsåtgärd, kommer att lagra lösenordet i databasen krypterat med MD5. Observera att eftersom MD5 är en enkelriktad krypteringsmetod kommer vi inte att kunna återställa lösenordet om användaren glömmer det.

Infoga registreringen i tabellen

Här är koden som vi använder för att infoga data i databasen. Vi kommer att ha all vår data tillgänglig i $formvars-arrayen.

funktion InsertIntoDB(&$formvars) ( $confirmcode = $this->MakeConfirmationMd5($formvars["email"]); $insert_query = " Sätt in i".$this->tabellnamn."(namn, e-post, användarnamn, lösenord, bekräftelsekod) värden ("" . $this->SanitizeForSQL($formvars["namn"]) . "", "" . $this -> SanitizeForSQL($formvars["e-post"]) , "" $this->SanitizeForSQL($formvars["användarnamn"]) "", "" . ", "" . $confirmcode . """; if(!mysql_query($insert_query,$this->connection)) ( $this->HandleDBError("Fel vid infogning av data i tabellen\nquery:$insert_query"); return false; return true;

Observera att vi använder PHP-funktionen md5() för att kryptera lösenordet innan vi infogar det i databasen.
Dessutom skapar vi den unika bekräftelsekoden från användarens e-postadress.

Skickar mejl

Nu när vi har registreringen i vår databas kommer vi att skicka ett bekräftelsemail till användaren. Användaren måste klicka på en länk i bekräftelsemailet för att slutföra registreringsprocessen.

function SendUserConfirmationEmail(&$formvars) ( $mailer = new PHPMailer(); $mailer->CharSet = "utf-8"; $mailer->AddAddress($formvars["email"],$formvars["name"]) ; $mailer->Subject = "Din registrering med ".$this->sitename" = $this->GetFromAddress($this->MakeConfirmationMd5($formvars; ])); $confirm_url = $this->GetAbsoluteURLFolder()."/confirmreg.php?code=".$confirmcode; $mailer->Body ="Hej ".$formvars["namn"]."\r\ n\r\n". "Tack för din registrering med ".$this->webbplatsnamn."\r\n". "Klicka på länken nedan för att bekräfta din registrering.\r\n." "$confirm_url\r \n". "\r\n". "Hälsningar,\r\n". "Webbmaster\r\n". $this->webbplatsnamn; if(!$mailer->Send()) ( $this-> HandleError("Det gick inte att skicka registreringsbekräftelsemail.");

Uppdateringar

9 januari 2012
Funktionerna Återställ lösenord/Ändra lösenord läggs till
Koden delas nu på GitHub.

Välkommen tillbakaUserFullName(); ?>!

Licens

Koden delas under LGPL-licens. Du kan fritt använda den på kommersiella eller icke-kommersiella webbplatser.

Inga relaterade inlägg.

Kommentarer till detta inlägg är stängda.

I den här artikeln kommer du att lära dig hur man skapar en registrerings- och behörighetsblankett använder HTML, JavaScript, PHP och MySql. Sådana formulär används på nästan alla webbplatser, oavsett typ. De är skapade för forumet, och för nätbutiken, och för sociala nätverk(som Facebook, Twitter, Odnoklassniki) och för många andra typer av webbplatser.

Om du har en webbplats på din lokala dator, så hoppas jag att du redan har det lokal server installerad och igång. Utan det kommer ingenting att fungera.

Skapa en tabell i databasen

För att implementera användarregistrering behöver vi först och främst en databas. Om du redan har det är det bra, annars måste du skapa det. I artikeln förklarar jag i detalj hur man gör detta.

Och så, vi har en databas (förkortat som DB), nu måste vi skapa en tabell användare där vi kommer att lägga till våra registrerade användare.

Jag förklarade också hur man skapar en tabell i en databas i artikeln. Innan vi skapar en tabell måste vi bestämma vilka fält den kommer att innehålla. Dessa fält kommer att motsvara fälten från registreringsformuläret.

Så, tänkte vi, föreställde oss vilka fält vårt formulär skulle ha och skapade en tabell användare med dessa fält:

• id- Identifierare. Fält id Varje tabell i databasen borde ha det.
• förnamn- För att spara namnet.
• efternamn- För att bevara efternamnet.
• e-post- För att spara postadressen. Vi kommer att använda e-post som inloggning, så detta fält måste vara unikt, det vill säga ha det UNIKA indexet.
• email_status- Fält för att ange om posten är bekräftad eller inte. Om e-postmeddelandet bekräftas kommer det att ha värdet 1, annars är värdet 0.
• Lösenord- För att spara lösenordet.

Om du vill att ditt registreringsformulär ska ha några andra fält kan du även lägga till dem här.

Det var allt, vårt bord användare redo. Låt oss gå vidare till nästa steg.

Databasanslutning

Vi har skapat databasen, nu måste vi ansluta till den. Vi kommer att knyta an till använder PHP MySQLi-tillägg.

Skapa en fil med namnet i mappen på vår webbplats dbconnect.php, och skriv följande skript i den:

DB-anslutningsfel. Felbeskrivning: ".mysqli_connect_error()."

"; exit(); ) // Ställ in anslutningskodningen $mysqli->set_charset("utf8"); // För enkelhetens skull, lägg till en variabel här som kommer att innehålla namnet på vår webbplats $address_site = "http://testwebbplats .local" ; ?>

Den här filen dbconnect.php kommer att behöva kopplas till formulärhanterare.

Lägg märke till variabeln $address_site, här angav jag namnet på min testwebbplats som jag kommer att arbeta med. Vänligen ange namnet på din webbplats i enlighet med detta.

Webbplatsens struktur

Låt oss nu titta på HTML-strukturen på vår webbplats.

Vi kommer att flytta sidans sidhuvud och sidfot till separata filer, header.php Och sidfot.php. Vi kommer att ta med dem på alla sidor. Nämligen på huvudsidan (fil index.php), till sidan med registreringsformuläret (fil form_register.php) och till sidan med auktoriseringsformuläret (fil form_auth.php).

Blockera med våra länkar, registrering Och tillstånd, lägg till dem i sidhuvudet så att de visas på alla sidor. En länk kommer att anges kl sidan med registreringsformulär(fil form_register.php) och den andra till sidan med fullmaktsformulär(fil form_auth.php).

Innehållet i filen header.php:

Namn på vår sida

Som ett resultat ser vår huvudsida ut så här:

Naturligtvis kan din sida ha en helt annan struktur, men detta är inte viktigt för oss nu. Huvudsaken är att det finns länkar (knappar) för registrering och auktorisering.

Låt oss nu gå vidare till registreringsformuläret. Som du redan förstår har vi den på fil form_register.php.

Gå till databasen (i phpMyAdmin), öppna tabellstrukturen användare och titta på vilka fält vi behöver. Det betyder att vi behöver fält för att ange för- och efternamn, ett fält för att ange postadress (E-post) och ett fält för att ange lösenord. Och av säkerhetsskäl kommer vi att lägga till ett fält för att ange en captcha.

På servern, som ett resultat av bearbetning av registreringsformuläret, kan olika fel uppstå på grund av vilka användaren inte kommer att kunna registrera sig. Därför, för att användaren ska förstå varför registreringen misslyckas, är det nödvändigt att visa meddelanden om dessa fel.

Innan du visar formuläret, lägg till ett block för att visa felmeddelanden från sessionen.

Och en sak till, om användaren redan är auktoriserad och av nyfikenhet går han direkt till registreringssidan genom att skriva i webbläsarens adressfält site_address/form_register.php, då i det här fallet, istället för registreringsformuläret, kommer vi att visa en rubrik som anger att han redan är registrerad.

I allmänhet filkoden form_register.php vi har det här:

Du är redan registrerad

I webbläsaren ser sidan med registreringsformuläret ut så här:

Genom att använda obligatoriskt attribut, vi har gjort alla fält obligatoriska.

Var uppmärksam på registreringsformulärets kod var captcha visas:

Vi angav sökvägen till filen i värdet för src-attributet för bilden captcha.php, som genererar denna captcha.

Låt oss titta på filkoden captcha.php:

Koden är väl kommenterad, så jag fokuserar bara på en punkt.

Inuti en funktion imageTtfText(), sökvägen till teckensnittet anges verdana.ttf. Så för att captcha ska fungera korrekt måste vi skapa en mapp teckensnitt, och placera teckensnittsfilen där verdana.ttf. Du kan hitta den och ladda ner den från Internet, eller ta den från arkivet med materialet i den här artikeln.

Vi är klara med HTML-strukturen, det är dags att gå vidare.

Kontrollerar e-postens giltighet med jQuery

Alla formulär måste kontrollera giltigheten av de angivna uppgifterna, både på klientsidan (med använder JavaScript, jQuery) och på serversidan.

Vi måste vara särskilt uppmärksamma på fältet E-post. Det är mycket viktigt att den angivna postadressen är giltig.

För detta inmatningsfält ställer vi in ​​e-posttypen (type="email"), detta varnar oss något för felaktiga format. Men detta räcker inte, för genom kodinspektören som webbläsaren ger oss kan vi enkelt ändra attributvärdet typ Med e-post på text, och det är det, vår check kommer inte längre att vara giltig.

Och i det här fallet måste vi göra en mer tillförlitlig kontroll. För att göra detta kommer vi att använda jQuery-biblioteket från JavaScript.

För att ansluta jQuery-biblioteket, i filen header.php mellan taggar , före den avslutande taggen , lägg till denna rad:

Omedelbart efter denna rad kommer vi att lägga till e-postvalideringskoden. Här kommer vi att lägga till en kod för att kontrollera längden på det angivna lösenordet. Dess längd måste vara minst 6 tecken.

Med detta skript kontrollerar vi den angivna e-postadressen för giltighet. Om användaren skrev in en felaktig e-post, visar vi ett felmeddelande om detta och inaktiverar knappen för att skicka formulär. Om allt är bra tar vi bort felet och aktiverar knappen för att skicka formuläret.

Och så är vi klara med formulärvalidering på kundsidan. Nu kan vi skicka det till servern, där vi även kommer att göra ett par kontroller och lägga till data i databasen.

Användarregistrering

Vi skickar formuläret till filen för behandling register.php, via POST-metoden. Namnet på denna hanterarfil anges i attributvärdet handling. Och sändningsmetoden anges i attributvärdet metod.

Öppna den här filen register.php och det första vi behöver göra är att skriva en sessionsstartfunktion och ansluta filen vi skapade tidigare dbconnect.php(I den här filen gjorde vi en koppling till databasen). Och låt oss omedelbart förklara cellerna felmeddelanden Och framgångsmeddelanden i den globala sessionsuppsättningen. I error_mesages vi kommer att registrera alla felmeddelanden som uppstår under formulärbearbetning och i framgångsmeddelanden, kommer vi att spela in glada meddelanden.

Innan vi fortsätter måste vi kolla har blanketten skickats in överhuvudtaget?. En angripare kan titta på attributvärdet handling från formuläret och ta reda på vilken fil som behandlar detta formulär. Och han kanske har idén att gå direkt till den här filen genom att skriva följande adress i webbläsarens adressfält: http://site_address/register.php

Så vi måste leta efter en cell i den globala POST-arrayen vars namn matchar namnet på vår "Register"-knapp från formuläret. På så sätt kontrollerar vi om knappen "Registrera" har klickats eller inte.

Om en angripare försöker gå direkt till den här filen får de ett felmeddelande. Låt mig påminna dig om att variabeln $address_site innehåller namnet på webbplatsen och den deklarerades i filen dbconnect.php.

Fel! huvudsida.

"); } ?>

Captcha-värdet i sessionen lades till när det genererades i filen captcha.php. Som en påminnelse kommer jag att visa dig denna kodbit från filen igen captcha.php, där captcha-värdet läggs till sessionen:

Låt oss nu gå vidare till själva verifieringen. I fil register.php, inuti if-blocket, där vi kontrollerar om knappen "Registrera" har klickats, eller snarare var kommentaren " anges" // (1) Utrymme för nästa kodbit"vi skriver:

//Kontrollera den mottagna captcha //Trimma mellanslagen från början och slutet av raden $captcha = trim($_POST["captcha"]); if(isset($_POST["captcha"]) && !empty($captcha))( //Jämför det mottagna värdet med värdet från sessionen. if(($_SESSION["rand"] != $captcha) && ($_SESSION ["rand"] != ""))( // Om captcha inte är korrekt, så återvänder vi användaren till registreringssidan, och där kommer vi att visa ett felmeddelande till honom att han skrev in fel captcha $error_message = "

Fel! Du skrev in fel captcha

"; // Spara felmeddelandet till sessionen. $_SESSION["error_messages"] = $error_message; // Returnera användaren till registreringssidans header("HTTP/1.1 301 flyttade permanent"); header("Plats: " .$address_site ."/form_register.php"); //Stoppa skriptet exit(); "

Fel! Det finns ingen verifieringskod, det vill säga en captcha-kod. Du kan gå till huvudsidan.

"); }

Därefter måste vi behandla mottagna data från POST-matrisen. Först och främst måste vi kontrollera innehållet i den globala POST-arrayen, det vill säga om det finns celler där vars namn motsvarar namnen på inmatningsfälten från vårt formulär.

Om cellen finns trimmar vi mellanrummen från början och slutet av raden från den här cellen, annars omdirigerar vi användaren tillbaka till sidan med registreringsformuläret.

Därefter, efter att vi har trimmat mellanrummen, lägger vi till raden i variabeln och kontrollerar denna variabel för tomhet, om den inte är tom, går vi vidare, annars omdirigerar vi användaren tillbaka till sidan med registreringsformuläret.

Klistra in den här koden på den angivna platsen" // (2) Utrymme för nästa kodbit".

/* Kontrollera om det finns data skickade från formuläret i den globala arrayen $_POST och linda in den inlämnade datan i vanliga variabler.*/ if(isset($_POST["first_name"]))( //Trimma mellanslagen från början och slutet av strängen $first_name = trim($_POST["first_name"]); //Kontrollera variabeln för tomhet if(!empty($first_name))( // För säkerhets skull, konvertera specialtecken till HTML-entiteter $first_name = htmlspecialchars($first_name, ENT_QUOTES) )else( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Ange ditt namn

Namnfältet saknas

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) if( isset($_POST["last_name"]))( //Trimma mellanslag från början och slutet av raden $last_name = trim($_POST["last_name"]); if(!empty($last_name)) ( // För säkerhets skull, konvertera specialtecken till HTML-entiteter $last_name = htmlspecialchars($last_name, ENT_QUOTES); )else( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Vänligen ange ditt efternamn

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Efternamnsfält saknas

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) if( isset($_POST["email"]))( //Trimma mellanslag från början och slutet av raden $email = trim($_POST["email"]); if(!empty($email)) ( $email = htmlspecialchars ($email, ENT_QUOTES); // (3) Kodplats för att kontrollera formatet på e-postadressen och dess unika )else( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Ange din e-postadress

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) if( isset($_POST["lösenord"]))( //Trimma mellanslag från början och slutet av strängen $password = trim($_POST["lösenord"]); if(!empty($password)) ( $password = htmlspecialchars ($password, ENT_QUOTES); //Kryptera lösenordet $password = md5($password."top_secret");else( //Spara felmeddelandet till sessionen. $_SESSION["error_messages"] . = "

Ange ditt lösenord

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) // (4) Plats för koden för att lägga till en användare till databasen

Av särskild betydelse är området e-post. Vi måste kontrollera formatet på den mottagna postadressen och dess unika karaktär i databasen. Det vill säga, finns det någon användare med samma e-postadress som redan är registrerad?

På angiven plats" // (3) Kodplats för att kontrollera formatet på postadressen och dess unika karaktär" lägg till följande kod:

//Kontrollera formatet på den mottagna e-postadressen med ett reguljärt uttryck $reg_email = "/^**@(+(*+)*\.)++/i"; //Om formatet på den mottagna e-postadressen inte matchar det reguljära uttrycket if(!preg_match($reg_email, $email))( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Du har angett ett felaktigt e-postmeddelande

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) // Vi kontrollerar om en sådan adress redan finns i databasen = $mysqli->query("SELECT `email` FROM `users` WHERE `email`="".$email."""); är exakt en rad, vilket betyder att användaren med denna e-postadress redan är registrerad if($result_query->num_rows == 1)( //Om resultatet inte är falskt if(($row = $result_query->fetch_assoc() ) != false) ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

En användare med denna e-postadress är redan registrerad

"; //Återför användaren till registreringssidans header("HTTP/1.1 301 flyttade permanent"); header("Plats: ".$adress_webbplats."/form_register.php"); )else( // Spara felmeddelandet till sessionen $_SESSION["error_messages"] .= "

Fel i databasfrågan

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttade permanent"); header("Plats: ".$address_site."/form_register.php"); ) /* stänger valet */ $ result_query-> close(); //Stoppa skriptet exit();

Och så är vi klara med alla kontroller, det är dags att lägga till användaren i databasen. På angiven plats" // (4) Plats för koden för att lägga till en användare till databasen" lägg till följande kod:

//Fråga för att lägga till en användare i databasen $result_query_insert = $mysqli->query("INSERT INTO `users` (first_name, last_name, email, password) VALUES ("".$first_name."", "".$last_name ." ", "".$email.", "".$password."")"); if(!$result_query_insert)( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Fel i begäran om att lägga till användare till databasen

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); )else( $_SESSION["success_messages"] = "

Registreringen slutförd framgångsrikt!!!
Nu kan du logga in med ditt användarnamn och lösenord.

"; //Skicka användaren till behörighetssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); ) /* Slutför begäran */ $ result_query_insert-> close(); //Stäng anslutningen till databasen $mysqli->close();

Om ett fel inträffade i begäran om att lägga till en användare till databasen, lägger vi till ett meddelande om detta fel till sessionen och återför användaren till registreringssidan.

Annars, om allt gick bra, lägger vi också till ett meddelande till sessionen, men den här gången är det trevligare, nämligen att vi berättar för användaren att registreringen lyckades. Och vi omdirigerar den till sidan med behörighetsformuläret.

Skriptet för att kontrollera e-postadressens format och lösenordslängden finns i filen header.php, så det kommer också att gälla för fält från detta formulär.

Sessionen startas också i filen header.php, alltså i filen form_auth.php Det finns ingen anledning att starta en session, eftersom vi kommer att få ett felmeddelande.

Som jag redan har sagt fungerar skriptet för att kontrollera e-postadressens format och lösenordslängd även här. Därför, om användaren anger en felaktig e-postadress eller kort lösenord, får han omedelbart ett felmeddelande. En knapp att komma in kommer att bli inaktiv.

Efter att ha åtgärdat felen, knappen att komma in blir aktiv, och användaren kommer att kunna skicka in formuläret till servern, där det kommer att behandlas.

Användarbehörighet

Att tillskriva värde handling behörighetshandikappet har en fil specificerad auth.php, betyder det att formuläret kommer att behandlas i denna fil.

Och så, öppna filen auth.php och skriv kod för att behandla auktoriseringsformuläret. Det första du behöver göra är att starta en session och ansluta filen dbconnect.php för att ansluta till databasen.

//Deklarera en cell för att lägga till fel som kan uppstå vid bearbetning av formuläret. $_SESSION["error_messages"] = ""; //Deklarera en cell för att lägga till lyckade meddelanden $_SESSION["success_messages"] = "";

/* Kontrollera om formuläret skickades in, det vill säga om du klickade på knappen Logga in. Om ja, så går vi vidare, om inte, kommer vi att visa ett felmeddelande till användaren som indikerar att han gick direkt till den här sidan. */ if(isset($_POST["btn_submit_auth"]) && !empty($_POST["btn_submit_auth"]))( //(1) Utrymme för nästa kodbit )else( exit("

Fel! Du har kommit åt den här sidan direkt, så det finns ingen data att bearbeta. Du kan gå till huvudsidan.

"); }

//Kontrollera den mottagna captcha if(isset($_POST["captcha"]))( //Trimma mellanslagen från början och slutet av raden $captcha = trim($_POST["captcha"]); if(! empty($captcha ))( //Jämför det mottagna värdet med värdet från sessionen. if(($_SESSION["rand"] != $captcha) && ($_SESSION["rand"] != "")) ( // Om captcha är felaktig , så returnerar vi användaren till auktoriseringssidan, och där kommer vi att visa ett felmeddelande till honom att han skrev in fel captcha $error_message = ".

Fel! Du skrev in fel captcha

"; // Spara felmeddelandet till sessionen. $_SESSION["error_messages"] = $error_message; // Returnera användaren till behörighetssidans header("HTTP/1.1 301 flyttade permanent"); header("Plats: " .$address_site ."/form_auth.php"); //Stoppa skriptet exit( )else( $error_message = ");

Fel! Captcha-inmatningsfältet får inte vara tomt.

"; // Spara felmeddelandet till sessionen. $_SESSION["error_messages"] = $error_message; // Returnera användaren till behörighetssidans header("HTTP/1.1 301 flyttade permanent"); header("Plats: " .$address_site ."/form_auth.php"); //Stoppa skriptet exit(); en begäran till databasen )else ( //Om captcha inte passeras avsluta("

Fel! Det finns ingen verifieringskod, det vill säga en captcha-kod. Du kan gå till huvudsidan.

"); }

Om användaren angav verifieringskoden korrekt, går vi vidare, annars returnerar vi honom till auktoriseringssidan.

Kollar postadressen

//Trimma mellanslag från början och slutet av raden $email = trim($_POST["email"]); if(isset($_POST["email"]))( if(!empty($email))( $email = htmlspecialchars($email, ENT_QUOTES); //Kontrollera formatet på den mottagna e-postadressen med ett reguljärt uttryck $ reg_email = " /^**@(+(*+)*\.)++/i"; //Om formatet på den mottagna e-postadressen inte matchar det reguljära uttrycket if(!preg_match($reg_email, $email ))( // Spara till sessionens felmeddelande. $_SESSION["error_messages"] .= "

Du angav en felaktig e-postadress

"; //Tillbaka användaren till auktoriseringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet till sessionen. $_SESSION["error_messages"] .= "

Fältet för att ange en postadress (e-post) får inte vara tomt.

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_register.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Inmatningsfält för e-post saknas

"; //Tillbaka användaren till auktoriseringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); ) // (3) Område för lösenordsbearbetning

Om användaren har angett en e-postadress i fel format eller om värdet på e-postadressfältet är tomt, så returnerar vi honom till behörighetssidan där vi visar ett meddelande om detta.

Lösenordsverifiering

Nästa fält att bearbeta är lösenordsfältet. Till angiven plats" //(3) Plats för lösenordsbearbetning", vi skriver:

If(isset($_POST["lösenord"]))( //Trimma mellanslag från början och slutet av strängen $password = trim($_POST["lösenord"]); if(!empty($password))( $password = htmlspecialchars($password, ENT_QUOTES); //Kryptera lösenordet $password = md5($password."top_secret");else( //Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Ange ditt lösenord

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); ) )else ( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Lösenordsfältet saknas

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); )

Här använder vi md5()-funktionen för att kryptera det mottagna lösenordet, eftersom våra lösenord finns i krypterad form i databasen. Ytterligare ett hemligt ord i kryptering, i vårt fall " topp hemligt" måste vara den som användes när användaren registrerades.

Nu måste du göra en förfrågan till databasen för att välja en användare vars e-postadress är lika med den mottagna e-postadressen och vars lösenord är lika med det mottagna lösenordet.

//Fråga i databasen baserat på användarens val. $result_query_select = $mysqli->query("VÄLJ * FRÅN `användare` WHERE email = "".$email."" OCH lösenord = "".$password."""); if(!$result_query_select)( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Frågefel vid val av användare från databasen

"; //Tillbaka användaren till registreringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); )else( //Kontrollera om det inte finns någon användare med sådan data i databasen, visa sedan ett felmeddelande if($result_query_select->num_rows == 1)( // Om den angivna informationen matchar data från databasen, spara sedan inloggningen och lösenordet till sessionsarrayen["email"] = $_SESSION["lösenord"] = $password //Returnera användaren hemsida header("HTTP/1.1 301 flyttade permanent"); header("Plats: ".$adress_webbplats."/index.php"); )else( // Spara felmeddelandet i sessionen. $_SESSION["error_messages"] .= "

Felaktig inloggning och/eller lösenord

"; //Tillbaka användaren till auktoriseringssidans header("HTTP/1.1 301 flyttad permanent"); header("Plats: ".$address_site."/form_auth.php"); //Stoppa skriptet exit(); ))

Gå ut från platsen

Och det sista vi implementerar är proceduren för att lämna platsen. För närvarande visar vi i rubriken länkar till behörighetssidan och registreringssidan.

I webbplatshuvudet (fil header.php), med hjälp av sessionen kontrollerar vi om användaren redan är auktoriserad. Om inte, visar vi registrerings- och auktoriseringslänkarna, annars (om han är auktoriserad), så visar vi länken istället för registrerings- och auktoriseringslänkarna Utgång.

Ändrad kodbit från fil header.php:

Registrering

Utgång

När du klickar på utgångslänken från webbplatsen tas vi till en fil logga ut.php, där vi helt enkelt förstör cellerna med e-postadressen och lösenordet från sessionen. Efter detta återvänder vi användaren till sidan där länken klickades på utgång.

Filkod logout.php:

Det är allt. Nu vet du hur implementera och behandla registrerings- och behörighetsformulär användare på din webbplats. Dessa formulär finns på nästan alla webbplatser, så varje programmerare bör veta hur man skapar dem.

Vi lärde oss också hur man validerar indata, både på klientsidan (i webbläsaren, med JavaScript, jQuery) och på serversidan (med PHP). Vi lärde oss också genomföra ett förfarande för att lämna platsen.

Alla skript har testats och fungerar. Du kan ladda ner arkivet med filerna från denna lilla webbplats från denna länk.

I framtiden kommer jag att skriva en artikel där jag ska beskriva. Och jag planerar också att skriva en artikel där jag ska förklara (utan att ladda om sidan). Så för att hålla dig informerad om utgivningen av nya artiklar kan du prenumerera på min webbplats.

Om du har några frågor, vänligen kontakta mig, och om du märker något fel i artikeln, vänligen meddela mig.

Lektionsplan (del 5):

1. Skapa en HTML-struktur för auktoriseringsformuläret
2. Vi behandlar de mottagna uppgifterna
3. Vi visar användarens hälsning i sidhuvudet

Gillade du artikeln?

Senast uppdaterad: Tis 19 september 2006

session_register

(PHP 4, PHP 5)session_register -- Registrera en eller flera globala variabler med den aktuella sessionen

Beskrivning

bool session_register(blandat namn [, blandat ...])
session_register() accepterar ett variabelt antal argument, varav alla kan vara antingen en sträng som innehåller namnet på en variabel eller en array som består av variabelnamn eller andra arrayer. För varje namn, session_register() registrerar den globala variabeln med det namnet i den aktuella sessionen.

Varning

Om du vill att ditt skript ska fungera oavsett register_globals måste du istället använda $_SESSION-matrisen eftersom $_SESSION-poster registreras automatiskt. Om ditt skript använder session_register(), kommer det inte att fungera i miljöer där PHP-direktivet register_globals är inaktiverat.

register_globals: viktig anmärkning: Sedan PHP 4.2.0 är standardvärdet för PHP-direktivet register_globals av, och det är helt borttaget från och med PHP 6.0.0. PHP-communityt uppmuntrar alla att inte förlita sig på detta direktiv utan istället använda andra medel, såsom superglobals .

Varning

Detta registrerar en global variabel. Om du vill registrera en sessionsvariabel från en funktion måste du se till att göra den global med hjälp av global nyckelordet eller $GLOBALS-matrisen, eller använd de speciella sessionsmatriserna som anges nedan.

Denna funktion returnerar TRUE när alla variabler har registrerats med sessionen. Om session_start() anropades inte innan den här funktionen anropades, ett implicit anrop till session_start() utan parametrar kommer att göras. $_SESSION härmar inte detta beteende och kräver session_start() innan användning.

Du kan också skapa en sessionsvariabel genom att helt enkelt ställa in lämplig medlem av $_SESSION eller $HTTP_SESSION_VARS (PHP

Idag ska vi titta på utnyttjandet av en kritisk 1-dags sårbarhet i det populära CMS Joomla, som exploderade på Internet i slutet av oktober. Vi kommer att prata om sårbarheter med siffror CVE-2016-8869, CVE-2016-8870 Och CVE-2016-9081. Alla tre kommer från ett stycke kod som försvann i ramverkets djup i fem långa år och väntade i kulisserna, bara för att sedan bryta sig loss och föra med sig kaos, hackade sajter och tårar från oskyldiga användare av denna Joomla. Endast de tappraste och modigaste utvecklarna, vars ögon är röda av bildskärmarnas ljus, och vars tangentbord är fulla av brödsmulor, kunde utmana de rasande onda andarna och lägga sina huvuden på fixernas altare.

VARNING

All information tillhandahålls endast i informationssyfte. Varken redaktörerna eller författaren är ansvariga för eventuell skada orsakad av materialet i denna artikel.

Där allt började

Den 6 oktober 2016 skapade Demis Palma ett ämne på Stack Exchange där han frågade: varför, i själva verket, i Joomla version 3.6 finns det två metoder för att registrera användare med samma namn register()? Den första finns i UsersControllerRegistration-kontrollern och den andra finns i UsersControllerUser-kontrollern. Damis ville veta om metoden UsersControllerUser::register() användes någonstans, eller om det bara var en evolutionär anakronism kvar från den gamla logiken. Hans oro var att även om den här metoden inte används av någon vy, kan den anropas av en skapad fråga. På vilket jag fick ett svar från en utvecklare under smeknamnet itoctopus, som bekräftade: problemet finns verkligen. Och skickade en rapport till Joomla-utvecklarna.

Sedan utvecklades händelserna snabbast. Den 18 oktober accepterade Joomla-utvecklare rapporten från Damis, som vid den tiden hade utarbetat en PoC som skulle tillåta användarregistrering. Han publicerade en anteckning på sin hemsida, där han talade i allmänna ordalag om problemet han hittade och sina tankar i denna fråga. Samma dag släpps en ny version av Joomla 3.6.3, som fortfarande innehåller sårbar kod.

Efter detta snurrar Davide Tampellini felet så att det inte registrerar en enkel användare utan en administratör. Och den 21 oktober kommer ett nytt fall till Joomlas säkerhetsteam. Det talas redan om att öka privilegierna. Samma dag dyker det upp ett meddelande på Joomlas hemsida att tisdagen den 25 oktober släpps nästa version med serienummer 3.6.3, vilket korrigerar en kritisk sårbarhet i systemkärnan.

25 oktober Joomla Security Strike Team hittar det senaste problemet som skapats av koden som upptäckts av Damis. Sedan skjuts en commit daterad den 21 oktober med det oansenliga namnet Prepare 3.6.4 Stable Release in i huvudgrenen av det officiella Joomla-förvaret, vilket fixar den olyckliga buggen.

Efter att detta kommit ut går många intresserade individer med i utvecklargemenskapen - de börjar främja sårbarheten och förbereder utnyttjande.

Den 27 oktober laddar forskaren Harry Roberts upp en färdig exploit till Xiphos Research-förrådet som kan ladda upp en PHP-fil till en server med ett sårbart CMS.

Detaljer

Nåväl, bakgrunden är över, låt oss gå vidare till den mest intressanta delen - analys av sårbarheten. Jag installerade Joomla 3.6.3 som en testversion, så alla radnummer kommer att vara relevanta för denna version. Och alla sökvägar till filerna som du kommer att se nedan kommer att indikeras i förhållande till roten av det installerade CMS.

Tack vare Damis Palmas upptäckt vet vi att det finns två metoder som utför användarregistrering i systemet. Den första används av CMS och finns i filen /components/com_users/controllers/registration.php:108. Den andra (den vi kommer att behöva anropa) bor i /components/com_users/controllers/user.php:293. Låt oss ta en närmare titt på det.

286: /** 287: * Metod för att registrera en användare. 288: * 289: * @return boolean 290: * 291: * @since 1.6 292: */ 293: public function register() 294: ( 295: JSession::checkToken("post") eller jexit(JText::_ ("JINVALID_TOKEN")); ... 300: // Hämta formulärdata 301: $data = $this->input->post->get("användare", array(), "array" . 315: $return = $model->validate($form, $data: // Kontrollera om det finns fel 318: if ($return === false) 319: ( ... 345: / /); Avsluta registreringen 346: $return = $model->register($data);

Här lämnade jag bara intressanta rader. Den fullständiga versionen av den sårbara metoden kan ses i Joomla-förvaret.

Låt oss ta reda på vad som händer under normal användarregistrering: vilken data som skickas och hur den behandlas. Om användarregistrering är aktiverat i inställningarna kan formuläret hittas på http://joomla.local/index.php/component/users/?view=registration.

En legitim begäran om användarregistrering ser ut som följande skärmdump.

Komponenten com_users ansvarar för att arbeta med användare. Var uppmärksam på uppgiftsparametern i begäran. Den har formatet $controller.$metod . Låt oss titta på filstrukturen.

Namn på skript i mappen kontroller motsvarar namnen på de anropade kontrollerna. Eftersom vår begäran nu innehåller $controller = "registrering" kommer filen att anropas registrering.php och dess register()-metod.

OBS, fråga: hur överför man registreringshanteringen till en sårbar plats i koden? Du har förmodligen redan gissat det. Namnen på de sårbara och verkliga metoderna är desamma (register), så vi behöver bara ändra namnet på den anropade kontrollern. Var finns vår sårbara kontrollant? Det stämmer, i filen user.php. Det visar sig att $controller = "användare" . Om vi ​​sätter ihop allt får vi task = user.register . Nu behandlas registreringsförfrågan med den metod vi behöver.

Det andra vi behöver göra är att skicka data i rätt format. Allt är enkelt här. Legitima register() förväntar sig av oss en array som heter jform , där vi skickar registreringsdata - namn, inloggning, lösenord, e-post (se skärmdump med begäran).

• /components/com_users/controllers/registration.php: 124: // Hämta användardata. 125: $requestData = $this->input->post->get("jform", array(), "array");

Vår klient får denna data från en array som kallas användare.

• /components/com_users/controllers/user.php: 301: // Hämta formulärdata. 302: $data = $this->input->post->get("användare", array(), "array");

Därför ändrar vi namnen på alla parametrar i begäran från jfrom till användare .

Vårt tredje steg är att hitta en giltig CSRF-token, eftersom det inte kommer att finnas någon registrering utan den.

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

Det ser ut som en MD5-hash, och du kan ta den till exempel från auktoriseringsformuläret på sajten /index.php/component/users/?view=login.

Nu kan du skapa användare med hjälp av önskad metod. Om allt fungerade, så grattis - du utnyttjade bara en sårbarhet CVE-2016-8870"Saknar behörighetskontroll för registrering av nya användare."

Så här ser det ut i metoden "working" register() från UsersControllerRegistration-kontrollanten:

• /components/com_users/controllers/registration.php: 113: // Om registreringen är inaktiverad - Omdirigera till inloggningssidan. 114: if (JComponentHelper::getParams("com_users")->get("allowUserRegistration") == 0) 115: ( 116: $this->setRedirect(JRoute::_("index.php?option=com_users&view= login", false)); 117: 118: return false; 119: )

Och så i sårbara:

• /components/com_users/controllers/user.php:

Ja, inget sätt.

För att förstå det andra, mycket allvarligare problemet, låt oss skicka förfrågan vi skapade och se hur den exekveras i olika delar av koden. Här är delen som är ansvarig för att validera användarens inlämnade data i arbetsmetoden:

Fortsättning är endast tillgänglig för medlemmar

Alternativ 1. Gå med i "site"-gemenskapen för att läsa allt material på sajten

Medlemskap i communityn inom den angivna perioden ger dig tillgång till ALLT hackermaterial, ökar din personliga kumulativa rabatt och låter dig samla ett professionellt Xakep Score-betyg!

En handledning för nybörjaren! Oavsett var du går på Internet finns det en häftklammer som du hittar nästan överallt - användarregistrering. Oavsett om du behöver dina användare för att registrera sig för säkerhet eller bara för en extra funktion, finns det ingen anledning att inte göra det med denna enkla handledning . I den här handledningen kommer vi att gå igenom grunderna i användarhantering och sluta med ett enkelt medlemsområde som du kan implementera på din egen webbplats.

Om du behöver någon extra hjälp eller vill ha en genväg, kolla in utbudet av PHP-tjänsteleverantörer på Envato Studio. Dessa erfarna utvecklare kan hjälpa dig med allt från en snabb buggfix till att utveckla en hel app från grunden. Så bara bläddra bland leverantörerna, läs recensionerna och betygen och välj den rätta för dig.

Introduktion

I den här handledningen kommer vi att gå igenom varje steg för att skapa ett användarhanteringssystem, tillsammans med ett privat meddelandesystem mellan användare. Vi kommer att göra detta med PHP, med en MySQL-databas för att lagra all användarinformation. Denna handledning riktar sig till absoluta nybörjare till PHP, så inga förkunskaper alls krävs - faktiskt kan du bli lite uttråkad om du är en erfaren PHP-användare!

Denna handledning är avsedd som en grundläggande introduktion till sessioner och till att använda databaser i PHP. Även om slutresultatet av denna handledning kanske inte omedelbart verkar användbart för dig, kommer de färdigheter du får från den här handledningen att låta dig fortsätta att producera ett eget medlemssystem; som passar dina egna behov.

Innan du börjar den här handledningen, se till att du har följande information till hands:

• Databasvärdnamn- det här är servern som din databas ligger på, i de flesta situationer kommer detta helt enkelt att vara "localhost".
• Databasnamn, Databasanvändarnamn, Databaslösenord- Innan du startar den här handledningen bör du skapa en MySQL-databas om du har möjligheten eller har informationen till hands för att ansluta till en befintlig databas. Denna information behövs genom hela handledningen.

Om du inte har den här informationen bör din värdleverantör kunna tillhandahålla detta till dig.

Nu när vi har fått formaliteterna ur vägen, låt oss börja med handledningen!

Steg 1 - Inledande konfiguration

Installation av databasen

Som anges i introduktionen behöver du en databas för att fortsätta förbi denna punkt i handledningen. Till att börja med kommer vi att göra en tabell i denna databas för att lagra vår användarinformation.

Tabellen som vi behöver lagrar vår användarinformation; för våra syften kommer vi att använda en enkel tabell, men det skulle vara lätt att lagra mer information i extra kolumner om det är vad du behöver. I vårt system behöver vi följande fyra kolumner:

• Användar ID (Primärnyckel)
• Användarnamn
• Lösenord
• E-postadress

I databastermer, a Primärnyckelär fältet som unikt identifierar raden. I det här fallet kommer UserID att vara vår primära nyckel. Eftersom vi vill att detta ska öka varje gång en användare registrerar sig, kommer vi att använda det speciella MySQL-alternativet - auto_increment .

SQL-frågan för att skapa vår tabell ingår nedan och kommer vanligtvis att köras på fliken "SQL" i phpMyAdmin.

SKAPA TABELL `användare` (`Användar-ID` INT(25) NOT NULL AUTO_INCREMENT PRIMARY KEY , `Användarnamn` VARCHAR(65) NOT NULL , `Lösenord` VARCHAR(32) NOT NULL , `E-postadress` VARCHAR(255) NOT NULL);

Skapa en basfil

För att förenkla skapandet av vårt projekt kommer vi att göra en basfil som vi kan inkludera i var och en av de filer vi skapar. Den här filen kommer att innehålla databasanslutningsinformationen, tillsammans med vissa konfigurationsvariabler som hjälper oss på vägen.

Börja med att skapa en ny fil: base.php , och skriv in följande kod i den:

Låt oss ta en titt på några av dessa rader? Det finns några funktioner här som vi har använt och ännu inte förklarat, så låt oss ta en titt igenom dem snabbt och förstå dem – om du redan förstår grunderna i PHP, kanske du vill hoppa förbi den här förklaringen.

Session_start();

Den här funktionen startar en session för den nya användaren, och senare i den här handledningen kommer vi att lagra information i den här sessionen så att vi kan känna igen användare som redan har loggat in. Om en session redan har skapats kommer den här funktionen att känna igen den och föra över den sessionen till nästa sida.

Mysql_connect($dbhost, $dbuser, $dbpass) or die("MySQL Error: " . mysql_error()); mysql_select_db($dbname) or die("MySQL Error: " . mysql_error());

Var och en av dessa funktioner utför en separat men länkad uppgift. Funktionen mysql_connect kopplar vårt skript till databasservern med hjälp av informationen vi gav den ovan, och funktionen mysql_select_db väljer sedan vilken databas som ska användas med skriptet. Om någon av funktionerna inte slutförs kommer tärningsfunktionen automatiskt att kliva in och stoppa skriptet från att bearbetas - vilket lämnar alla användare med meddelandet att det fanns ett MySQL-fel.

Steg 2 - Tillbaka till frontend

Vad behöver vi göra först?

Det viktigaste på vår sida är den första raden i PHP; den här raden kommer att inkludera filen som vi skapade ovan (base.php), och kommer i huvudsak att tillåta oss att komma åt allt från den filen i vår nuvarande fil. Vi kommer att göra detta med följande rad PHP-kod. Skapa en fil med namnet index.php och placera den här koden överst.

Börja HTML-sidan

Det första vi ska göra för vår frontend är att skapa en sida där användare kan ange sina uppgifter för att logga in, eller om de redan är inloggade på en sida där de kan välja vad de sedan vill göra. I denna handledning antar jag att användare har grundläggande kunskaper om hur HTML/CSS fungerar, och kommer därför inte att förklara denna kod i detalj; för tillfället kommer dessa element att vara oformaterade, men vi kommer att kunna ändra detta senare när vi skapar vår CSS-stilmall.

Använd filen som vi just har skapat (index.php), ange följande HTML-kod under PHP-raden som vi redan har skapat.

Förhoppningsvis den första och sista kodblock kommer inte att förvirra dig för mycket. Det vi verkligen behöver fastna i nu är vad ni alla har kommit till denna handledning för - PHP-koden. Vi går nu igenom det andra avsnittet en rad i taget, och jag ska förklara vad varje kodbit här är avsedd för.

$användarnamn = mysql_real_escape_string($_POST["användarnamn"]); $password = md5(mysql_real_escape_string($_POST["lösenord"]));

Det finns två funktioner som behöver förklaras för detta. För det första, mysql_real_escape_string - en mycket användbar funktion för att rensa databasindata. Det är inte en felsäker åtgärd, men detta kommer att hålla majoriteten av de skadliga hackarna ute genom att ta bort oönskade delar av allt som har lagts in i vårt inloggningsformulär. För det andra, md5 Det skulle vara omöjligt att gå in på detaljer här, men den här funktionen krypterar helt enkelt allt som skickas till den - i det här fallet användarens lösenord - för att förhindra nyfikna ögon från att läsa det.

$checklogin = mysql_query("VÄLJ * FRÅN användare WHERE Användarnamn = "".$användarnamn."" OCH Lösenord = "".$lösenord."""); if(mysql_num_rows($checklogin) == 1) ( $row = mysql_fetch_array($checklogin); $email = $row["E-postadress"]; $_SESSION["Användarnamn"] = $användarnamn; $_SESSION["E-postadress"] = $email; $_SESSION["Inloggad"] = 1;

Här har vi kärnan i vår inloggningskod; För det första kör vi en fråga på vår databas. I denna fråga söker vi efter allt som har med en medlem att göra, vars användarnamn och lösenord matchar värdena för vårt $username och $password som användaren har angett. På nästa rad har vi ett if-uttalande, där vi kontrollerar hur många resultat vi har fått - om det inte finns några resultat kommer detta avsnitt inte att behandlas. Men om det blir ett resultat vet vi att användaren finns, och därför kommer vi att logga in dem.

De nästa två raderna är för att hämta användarens e-postadress. Vi har redan denna information från frågan som vi redan har kört, så vi kan enkelt komma åt denna information. Först får vi en uppsättning av data som har hämtats från databasen - i det här fallet använder vi PHP-funktionen mysql_fetch_array . Jag har sedan tilldelat värdet för fältet EmailAddress till en variabel som vi kan använda senare.

Nu ställer vi in ​​sessionen. Vi lagrar användarens användarnamn och e-postadress i sessionen, tillsammans med ett speciellt värde för att vi ska veta att de har loggats in med det här formuläret META REFRESH i koden.

Så, hur ser vårt projekt för närvarande ut för en användare?

Bra! Det är dags att gå vidare nu, för att se till att människor faktiskt kan komma in på din webbplats.

Låt folket registrera sig

Det är bra att ha ett inloggningsformulär på din sida, men nu måste vi låta användarna kunna använda det - vi måste skapa ett inloggningsformulär. Skapa en fil som heter register.php och lägg in följande kod i den.

Så det finns inte mycket nytt PHP som vi ännu inte har lärt oss i det avsnittet. Låt oss dock ta en snabb titt på den där SQL-frågan och se om vi kan ta reda på vad den gör.

$registerquery = mysql_query("INSERT I användare (användarnamn, lösenord, e-postadress) VÄRDEN("".$användarnamn.", "".$lösenord.", "".$email."")");

Så här lägger vi till användaren i vår databas. Den här gången, istället för att hämta data, infogar vi den; så vi specificerar först vilka kolumner vi anger data i (glöm inte, vårt användar-ID kommer upp automatiskt). I området VALUES() är vi berätta vad den ska lägga i varje kolumn; i det här fallet våra variabler som kom från användarens input. Så låt oss prova; när du har skapat ett konto på ditt helt nya registreringsformulär, här är vad du kommer att se för medlemsområdet.

Se till att de kan logga ut

Vi är nästan i slutet av det här avsnittet, men det är en sak till som vi behöver innan vi är klara här - ett sätt för användare att logga ut från sina konton. Detta är väldigt lätt att göra (lyckligtvis för oss); skapa en ny fil med namnet logout.php och skriv in följande i den.

I detta återställer vi först vår globala $_SESSION-array, och sedan förstör vi sessionen helt.

Och det är slutet på det avsnittet och slutet på PHP-koden. Låt oss nu gå vidare till vårt sista avsnitt.

Steg 3 - Bli stylad

Jag tänker inte förklara mycket i det här avsnittet - om du inte förstår HTML/CSS skulle jag starkt rekommendera när av de många utmärkta handledningarna på den här webbplatsen för att komma igång. Skapa en ny fil med namnet style.css och skriv in följande i den; detta kommer att utforma alla sidor som vi har skapat hittills.

* ( marginal: 0; utfyllnad: 0; ) body ( font-family: Trebuchet MS; ) a ( färg: #000; ) a:hover, a:active, a:visited ( text-decoration: none; ) #main ( bredd: 780px; marginal: 0 auto; margin-top: 50px; utfyllnad: 10px; kant: 1px fast #CCC; bakgrundsfärg: #EEE; ) form fieldset ( kantlinje: 0; ) form fieldset p br ( clear: vänster; ) etikett ( marginal-top: 5px; display: block; width: 100px; utfyllnad: 0; float: left; ) input ( font-family: Trebuchet MS; kant: 1px solid #CCC; margin-bottom: 5px; bakgrundsfärg: #FFF: 2px ) input:hover (kant: 1px solid #222; bakgrundsfärg: #EEE;)

Låt oss nu ta en titt på några skärmdumpar av hur vårt slutprojekt ska se ut:

Inloggningsformuläret.

Medlemsområdet.

Anmälningsformuläret.

Och slutligen...

Och det är det! Du har nu ett medlemsområde som du kan använda på din webbplats. Jag kan se många människor skakar på huvudet och skriker åt sina monitorer att det inte är någon nytta för dem - du har rätt. Men vad jag hoppas att alla nybörjare till PHP har lärt sig är grunderna i hur man använder en databas och hur man använder sessioner för att lagra information. De livsviktiga färdigheterna för att skapa vilken webbapplikation som helst.

• Prenumerera på NETTUTS RSS-flöde för fler dagliga webbutvecklingstips och artiklar.