Dall'autore: prima o poi ogni sviluppatore web si trova di fronte al compito di limitare l'accesso a una determinata pagina/pagine o directory. Può essere solo una pagina segreta del sito, la parte amministrativa del sito, o qualsiasi altra sezione, l'accesso a cui vogliamo limitare e fornire solo una password. Per fare ciò, puoi ovviamente utilizzare gli strumenti del server. Penso che qualsiasi hosting moderno abbia una funzione di password della directory, in cui è possibile creare un utente, assegnargli una password e, dopo aver password la directory, l'accesso alla directory chiusa verrà fornito solo dopo aver inserito il login e la password corretti. Ma a volte vuoi scrivere qualcosa da solo, qualcosa di veloce, semplice, ma allo stesso tempo affidabile ...

In questo tutorial proveremo a scrivere il nostro semplice sistema di autorizzazione. Avremo una pagina segreta - ad esempio, sarà una pagina amministratore, l'accesso a cui forniremo solo per un utente autorizzato. Il nostro sistema di autorizzazione sarà basato sul meccanismo di sessione. Prima di continuare questa lezione, ti consiglio di familiarizzare con una delle mie lezioni precedenti, in cui, in particolare, consideriamo il lavoro delle sessioni -.

In breve, tutto il lavoro con le sessioni può essere suddiviso in 3 fasi:

Apertura della sessione. In tutte le pagine in cui è implicato il lavoro con le sessioni, la sessione deve essere avviata utilizzando la funzione session_start().

Registrazione delle variabili di sessione.

Annullamento della registrazione delle variabili di sessione utilizzando la funzione unset() e chiusura della sessione con la funzione session_destroy().

Passo 1

Quindi, per il nostro lavoro, creeremo 3 file: Home page (index.php), Contatti (contact.php) e Admin (admin.php). Attiro la vostra attenzione sul fatto che l'estensione del file a cui limiteremo l'accesso deve essere .php. Come hai intuito, limiteremo l'accesso al file admin.php. Il codice di tutti i file è il più semplice: è una specie di menu in linea con collegamenti ad altre pagine e sotto c'è il testo individuale di ogni pagina in modo che possiamo distinguerli l'uno dall'altro. Ad esempio, ecco il codice per la pagina dell'indice:

Casa | Contatti | Pannello di Amministrazione

---

Questa è la pagina principale

Il resto delle pagine, come ho detto, differisce da esso solo nel testo dopo il tag di riga. Non ho creato pagine a tutti gli effetti con meta tag, poiché il nostro compito è solo quello di limitare l'accesso a una determinata pagina.

Passo 2

Finora, possiamo esplorare liberamente tutte le pagine, inclusa la pagina di amministrazione. Come limitiamo l'accesso ad esso? Come sarà l'algoritmo? Faremo quanto segue: all'inizio della pagina, controlleremo se l'etichetta di cui abbiamo bisogno è nella sessione o, più semplicemente, se esiste una specifica variabile di sessione (puoi anche controllare se il valore della variabile di sessione è uguale a un valore specifico). Se non esiste tale variabile, l'utente che richiede questa pagina non è autorizzato, il che significa che lo reindirizzeremo alla pagina di autorizzazione, dove gli verrà chiesto di compilare un modulo con un nome e una password. L'algoritmo è estremamente semplice: implementiamolo. Vai al file admin.php, apri la costruzione PHP in alto e scrivi il seguente codice:

inizio_sessione (); if (! $ _SESSION ["admin"]) ( intestazione ("Posizione: enter.php"); Uscita;

Leggiamo questo codice ora. In primo luogo, abbiamo aperto una sessione, come ricorderete: questo è un prerequisito quando si lavora con le sessioni. Inoltre, abbiamo creato una semplice condizione, che può essere letta in questo modo: "se l'elemento admin non esiste nell'array $ _SESSION, eseguiremo il blocco di azioni racchiuso tra parentesi operatore". E nel blocco di codice, usiamo la funzione header() per reindirizzare l'utente alla pagina enter.php (questa è la pagina di autorizzazione). Dopo la funzione header(), assicurarsi di terminare l'esecuzione dello script utilizzando la funzione exit(). Se la condizione non è soddisfatta, ad esempio, l'array $ _SESSION conterrà l'elemento admin - ciò significa che l'utente è già stato autorizzato con successo e salteremo il blocco di azione tra parentesi operatore, ovvero non si verificherà alcun reindirizzamento e mostriamo la pagina richiesta.

Passaggio 3

Ora dobbiamo creare una pagina di autorizzazione - enter.php. Per fare ciò, copia il codice, ad esempio, dalla pagina contact.php, crea un nuovo file e incollaci il codice copiato. Salva il file con il nome enter.php. Ora in questa pagina scriveremo un semplice modulo per inserire un nome utente e una password:

Casa | Contatti | Pannello di Amministrazione

---

Questa è la pagina di accesso.

Nome utente:
Parola d'ordine:

< p > < a href = "index.php" >casa< / a > | < a href = "contact.php" >Contatti< / a > | < a href = "admin.php" >Pannello di Amministrazione< / a > < / p > < hr / > < br / > < form method = "post" > Nome utente:< input type = "text" name = "user" / > < br / > Parola d'ordine:< input type = "password" name = "pass" / > < br / > < input type = "submit" name = "submit" value = "Entrare" / > < / form >

Tutto è semplice qui. Ci sono 2 campi nel modulo: un campo per inserire un login (gli abbiamo dato il nome "utente") e un campo per una password (denominato "pass"). Abbiamo anche creato un pulsante (nome "invia"), cliccando sul quale verranno inviati i dati del modulo. I dati vengono inviati dal metodo post - lo abbiamo specificato nell'attributo method del tag form - e verranno elaborati nella stessa pagina. Ora possiamo provare ad andare alla pagina di amministrazione. Se tutto viene fatto senza errori, non saremo in grado di arrivarci, ma saremo immancabilmente nella pagina di autorizzazione.

Meraviglioso!

Passaggio 4

Successivamente, dobbiamo scrivere un gestore sulla pagina con il modulo, che accetterà i dati dal modulo e confronterà se il login e la password del modulo corrispondono a quelli che abbiamo. Per fare ciò, apri il costrutto PHP nella parte superiore della pagina di autorizzazione e inizia a scrivere il codice. Per cominciare, dobbiamo aprire una sessione - dopo tutto, è qui che creeremo un'etichetta nella sessione se vengono ricevuti il ​​nome utente e la password corretti. Nella stessa pagina, memorizzeremo il login e la password dell'amministratore. Solitamente questi dati sono memorizzati in un database (DB), ma avremo solo 1 utente (amministratore), e quindi non è del tutto razionale memorizzare i suoi dati per entrare nel database. Se ci sarà più di un utente, ad es. noi, ad esempio, stiamo scrivendo un progetto in cui c'è la registrazione, allora, ovviamente, sarà difficile fare a meno di un database in questo caso.

Quindi, il nostro login sarà "admin" e lo memorizzeremo nella variabile $ admin. La password sarà "mypass" e verrà memorizzata nella variabile $ pass. Ma non è consuetudine memorizzare le password in chiaro: ciò è contrario ai principi di sicurezza. Memorizzeremo la password in forma crittografata e la funzione md5() ci aiuterà a crittografarla. Questa funzione crittografa una stringa utilizzando un algoritmo speciale e in uscita otteniamo una stringa di 32 caratteri (si chiama hash). Se criptiamo la stringa "mypass" (questo può essere fatto, ad esempio, nel file contact.php):

echo md5 ("miopass");

quindi in uscita otterremo la riga "a029d0df84eb5549c641e04a9ef389e5" - questa sarà la nostra password crittografata. Finora, il codice della pagina di autorizzazione sarà simile a questo:

Casa | Contatti | Pannello di Amministrazione

---

Questa è la pagina di accesso.

Nome utente:
Parola d'ordine:

inizio_sessione (); $ amministratore = "amministratore"; $ pass = "a029d0df84eb5549c641e04a9ef389e5"; < p > < a href = "index.php" >casa< / a > | < a href = "contact.php" >Contatti< / a > | < a href = "admin.php" >Pannello di Amministrazione< / a > < / p > < hr / > < br / > < form method = "post" > Nome utente:< input type = "text" name = "user" / > < br / > Parola d'ordine:< input type = "password" name = "pass" / > < br / > < input type = "submit" name = "submit" value = "Entrare" / > < / form >

Passaggio 5

Ora controlliamo quello che abbiamo ottenuto dal form con quello che abbiamo nelle variabili con login e password. Lo faremo in modo condizionale, solo se viene premuto il pulsante del modulo. Come possiamo verificarlo? Il pulsante ha un nome ("invia") e passiamo i dati utilizzando il metodo post. Di conseguenza, possiamo semplicemente verificare se l'elemento di invio esiste nell'array $ _POST. Se c'è, è stato premuto il pulsante e eseguiremo azioni per verificare i dati inviati, altrimenti non faremo nulla. Dopo aver dichiarato login e password, scriviamo la condizione:

if ($ _ POST ["submit"]) (if ($ admin == $ _POST ["user"] AND $ pass == md5 ($ _ POST ["pass"])) ($ _SESSION ["admin"] = $ admin; header ("Location: admin.php"); exit;) else echo "

Il login o la password non sono corretti!

"; }

if ($ _POST ["invia"]) ( if ($ admin == $ _POST ["utente"] AND $ pass == md5 ($ _POST ["pass"])) ( $ _SESSION ["admin"] = $ admin; Uscita; ) altro eco " Il login o la password non sono corretti! " ;

Abbiamo creato la condizione per il controllo di login e password come se fosse doppia. Questo viene fatto usando l'operatore logico AND (può anche essere scritto in questo modo - "&&"). La condizione può essere letta come segue: "if (la variabile $ admin è uguale all'elemento utente nell'array $ _POST e la variabile $ pass è uguale all'hash dell'elemento pass nell'array $ _POST) then (esegui l'action block ) altrimenti visualizziamo il testo' Login o password non sono corretti!'

Se la coppia login-password corrisponde, allora registriamo la variabile di sessione $ _SESSION ["admin"] e reindirizziamo l'utente alla pagina di amministrazione - admin.php.
Proviamo ora a testare ciò che abbiamo già creato. Se inseriamo un nome utente e una password deliberatamente falsi, riceveremo un messaggio di avviso che "Login o password non sono corretti!". Ora proviamo a inserire i dati di accesso corretti. Se non abbiamo commesso errori da nessuna parte, dopo aver fatto clic sul pulsante "Accedi" saremo nella pagina di amministrazione.

Passaggio 6

Ora resta da aggiungere alcune piccole cose. Ad esempio, ora siamo autorizzati nel sistema, ma se inseriamo l'indirizzo della pagina di autorizzazione nella barra degli indirizzi, ci andremo con calma e vedremo il modulo di autorizzazione. Questo non dovrebbe essere il caso: solo un utente non autorizzato dovrebbe vedere il modulo. come possiamo fissare questo? Ricorda che nella pagina admin.php abbiamo controllato se c'era un tag nella sessione. Se non è presente, abbiamo trasferito l'utente alla pagina di autorizzazione. Qui possiamo fare lo stesso, solo il contrario. Cioè, controlliamo anche se c'è un'etichetta nella sessione. Solo ora trasferiremo l'utente alla pagina di amministrazione, se esiste tale etichetta. Questo è, in linea di principio, logico. Se è presente un'etichetta, l'utente è già autorizzato e possiamo trasferirlo alla pagina di amministrazione. Nella pagina enter.php dopo l'inizio della sessione, aggiungi il seguente codice:

if ($ _ SESSION ["admin"]) (header ("Location: admin.php"); exit;)

if ($ _SESSION ["admin"]) ( intestazione ("Posizione: admin.php"); Uscita;

Ora, se un utente autorizzato tenta di inserire il nome della pagina di autorizzazione nella barra degli indirizzi, verrà trasferito alla pagina di amministrazione. Un utente non autorizzato potrà accedere liberamente alla pagina di autorizzazione.

Passaggio 7

Il momento successivo che dobbiamo fornire è l'implementazione del logout di un utente autorizzato, ovvero, diciamo che l'amministratore ha terminato il suo lavoro e ha bisogno di disconnettersi in modo che nessun altro possa lavorare con il suo account. Per fare ciò, aggiungi il link "Logout" nella pagina admin.php. Il collegamento porterà alla stessa pagina, verrà aggiunto solo il parametro di cui abbiamo bisogno. Il parametro viene aggiunto utilizzando un punto interrogativo:

Uscita

< a href = "admin.php?do=logout" >Uscita< / a >

Questo collegamento può essere inserito nel punto in cui ne abbiamo bisogno - lo metterò dopo il testo della pagina. Per quanto riguarda il parametro, verrà passato dal metodo GET (ricorda che abbiamo passato i dati dal modulo come secondo parametro - POST). Con questo metodo, i dati vengono aggiunti all'indirizzo nella barra degli indirizzi e separati dall'indirizzo da un punto interrogativo. Passiamo un parametro - do - e allo stesso tempo gli assegniamo il valore "logout". Come possiamo ora annullare l'autorizzazione dell'utente? È molto semplice: qui saremo aiutati dalla seconda e dalla terza fase quando lavoriamo con le sessioni. Al caricamento della pagina, possiamo controllare il valore dell'elemento do dall'array $ _GET. Se è uguale alla riga "logout", annulliamo semplicemente la registrazione della variabile di sessione $ _SESSION ["admin"] e distruggiamo la sessione. Di conseguenza, non ci saranno tag nella sessione successiva e nel blocco successivo, dove controlliamo la presenza di un tag, l'utente verrà reindirizzato alla pagina di autorizzazione. È semplice.

Reg.ru: domini e hosting

Il più grande registrar e provider di hosting in Russia.

Più di 2 milioni di nomi di dominio in servizio.

Promozione, posta per dominio, soluzioni aziendali.

Più di 700mila clienti in tutto il mondo hanno già fatto la loro scelta.

* Passa il mouse per mettere in pausa lo scorrimento.

Indietro avanti

Creazione di un semplice sistema di registrazione degli utenti in PHP e MySQL

La creazione di un sistema di registrazione è un sacco di lavoro. Devi scrivere un codice che convalidi gli indirizzi e-mail, invii un'e-mail di conferma della registrazione, convalidi il resto dei campi del modulo e molto altro.

E anche dopo aver scritto tutto questo, gli utenti saranno riluttanti a registrarsi, perché richiede un certo sforzo da parte loro.

In questo tutorial, creeremo un sistema di registrazione molto semplice che non richiede né memorizza affatto le password! Il risultato sarà facile da modificare e aggiungere a un sito PHP esistente. Vuoi scoprire come funziona? Leggere sotto.

Ecco come funzionerà il nostro semplicissimo sistema:

Uniremo il modulo di accesso e la registrazione. Questo modulo avrà un campo per inserire un indirizzo email e un pulsante di registrazione;
- Quando si compila il campo con un indirizzo e-mail, cliccando sul pulsante di registrazione, verrà creato un record relativo a un nuovo utente, ma solo se l'indirizzo e-mail inserito non è stato trovato nel database.

Successivamente, viene creato un determinato insieme univoco casuale di simboli (token), che viene inviato alla posta specificata dall'utente sotto forma di un collegamento che sarà rilevante per 10 minuti;
- L'utente segue il collegamento al nostro sito web. Il sistema determina la presenza di un token e autorizza l'utente;

I vantaggi di questo approccio:

Non è necessario memorizzare password e convalidare i campi;
- Non c'è bisogno di recupero password, domande di sicurezza, ecc.;
- Dal momento in cui l'utente è registrato/autorizzato, puoi sempre essere sicuro che questo utente sarà nella tua zona di accesso (che l'indirizzo email è vero);
- Processo di registrazione incredibilmente semplice;

Screpolatura:

Sicurezza dell'account utente. Se qualcuno ha accesso alla posta dell'utente, può accedere.
- La posta elettronica non è sicura e può essere intercettata. Tieni presente che questa domanda è rilevante anche nel caso in cui la password sia stata dimenticata e debba essere ripristinata, o in qualsiasi sistema di autorizzazione che non utilizzi HTTPS per il trasferimento dei dati (login/password);
- Fino a quando non configuri il server di posta come necessario, c'è la possibilità che i messaggi con link all'autorizzazione finiscano nello spam;

Confrontando i vantaggi e gli svantaggi del nostro sistema, possiamo dire che il sistema ha un'elevata usabilità (la più conveniente per l'utente finale) e, allo stesso tempo, ha un indicatore di sicurezza basso.

Quindi si suggerisce di utilizzarlo per registrazioni su forum e servizi che non funzionano con informazioni importanti.

Come usare questo sistema

Nel caso in cui hai solo bisogno di utilizzare il sistema per autorizzare gli utenti sul tuo sito e non vuoi smontare questa lezione, ecco cosa devi fare:

Devi scaricare i sorgenti allegati alla lezione
- Trova il file nell'archivio table.sql Importalo nel tuo database utilizzando l'opzione di importazione in phpMyAdmin. Modo alternativo: aprire questo file con un editor di testo, copiare la query SQL ed eseguirla;
- Aprire include / main.php e compilare le impostazioni per la connessione al database (specificare l'utente e la password per la connessione al database, nonché l'host e il nome del database). Nello stesso file è necessario specificare anche un'e-mail che verrà utilizzata come indirizzo originale per i messaggi inviati dal sistema. Alcuni host bloccano le email in uscita finché non viene specificato un indirizzo email reale nel modulo, che è stato creato dal pannello di controllo dell'host, quindi inserisci un indirizzo reale;
- Scarica tutti i file index.php, protetto.php e le risorse e include le cartelle via FTP al tuo host;
- Aggiungi il codice sottostante ad ogni pagina PHP in cui vuoi visualizzare un modulo di autorizzazione;

Require_once "include /main.php"; $ utente = nuovo utente (); if (! $ user- & gtloggedIn ()) (redirect ("index.php");)
- Pronto!

Per coloro che sono interessati a come funziona il tutto, leggi qui sotto!

Il primo passo è scrivere il codice HTM del modulo di autorizzazione. Questo codice si trova nel file index.php... Questo file contiene anche codice PHP che elabora i dati del modulo e altre utili funzioni del sistema di autorizzazione. Puoi saperne di più su questo nella sezione Revisione del codice PHP di seguito.

index.php

Login o Registrati

Inserisci il tuo indirizzo email sopra e ti invieremo
un link di accesso.

Accedi / Registrati

Nella sezione head (tra i tag e) Ho incluso gli stili principali (in questa lezione non sono capiti, quindi puoi vederli tu stesso. La cartella asset / css / style.css). Prima del tag di chiusura Ho incluso la libreria jQuery e il file script.js, che scriveremo e analizzeremo di seguito.

JavaScript

jQuery tiene traccia dello stato del pulsante Registra / Accedi utilizzando la funzione e.preventDefault() e invia richieste AJAX. A seconda della risposta del server, visualizza un messaggio particolare e determina ulteriori azioni /

asset / 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"); e.preventDefault (); $ .post (this.action, (email: 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 (function () (form.addClass ("loading");)); $ (document) .ajaxComplete (function () (form. removeClass ("caricamento");));));

è stato aggiunto al modulo per visualizzare lo stato attuale della richiesta AJAX (reso possibile dai metodi ajaxStart()) e ajaxComplete () che puoi trovare verso la fine del file).

Questa classe mostra un file gif animato rotante (come se ci suggerisse che la richiesta è in fase di elaborazione) e funge anche da flag che impedisce il reinvio del modulo (quando il pulsante di registrazione è già stato premuto una volta). Classe .connesso- questo è un flag diverso - impostato quando l'e-mail è stata inviata. Questo flag blocca istantaneamente qualsiasi ulteriore azione con il modulo.

Schema del database

Il nostro sistema di registrazione incredibilmente semplice utilizza 2 tabelle MySQL (l'SQL è nel file table.sql). Il primo memorizza i dati sugli account utente. Il secondo memorizza le informazioni sul numero di tentativi di accesso.

Schema della tabella degli utenti.

Il sistema non utilizza password, come si può vedere nello schema. Puoi anche vedere la colonna su di esso gettone con gettoni adiacenti alla colonna token_validity... Il token viene installato non appena l'utente si connette al sistema, imposta la sua e-mail per l'invio di un messaggio (maggiori informazioni su questo nel prossimo blocco). Altoparlante token_validity imposta il tempo dopo 10 minuti, dopo il quale il token non è più valido.

Uno schema di tabella che conta il numero di tentativi di autorizzazione.

In entrambe le tabelle, l'indirizzo IP è memorizzato in una forma analizzata utilizzando la funzione ip2long in un campo intero.

Ora possiamo scrivere del codice PHP. La funzionalità principale del sistema è assegnata alla classe Utente.class.php che puoi vedere qui sotto.

Questa classe fa un uso estensivo di idorm (docs), queste librerie sono gli strumenti minimi richiesti per lavorare con i database. Gestisce l'accesso al database, la generazione e la convalida di token. Fornisce una semplice interfaccia per connettere facilmente il sistema di registrazione al tuo sito se utilizza PHP.

Utente.class.php

Classe Utente (// Private ORM case private $ orm; / ** * Trova un utente per token. Vengono presi in considerazione solo i token validi. Il token viene generato solo per 10 minuti dal momento in cui è stato creato * @param string $ token . Questo è quello desiderato. token * @return User. Restituisce il valore della funzione User * / public static function findByToken ($ token) (// trova il token nel database e assicurati che sia impostato il timestamp corretto $ risultato = ORM :: for_table ("reg_users") -> dove ("token", $ token) -> where_raw ("token_validity> NOW ()") -> trova_uno (); if (! $ risultato) (return false; ) return new User ($ risultato);) / ** * Autorizza o registra un utente * @param string $ email Indirizzo email personalizzato * @return User * / public static function loginOrRegister ($ email) (// Se tale utente esiste già, restituisce il valore della funzione Utente dall'indirizzo email specificato memorizzato nel database if (Utente :: esiste ($ email)) (restituisce nuovo Utente ($ email);) // Altrimenti, crea un nuovo utente body nel database e restituisce il valore della funzione User :: create dall'e-mail specificata return User :: create ($ email); ) / ** * Crea un nuovo utente e salva nel database * @param string $ email. Indirizzo email personalizzato * @return User * / private static function create ($ email) (// Scrive un nuovo utente e restituisce il risultato della funzione Utente da questi valori $ risultato = ORM :: for_table ("reg_users") - > create (); $ risultato-> email = $ email; $ risultato-> salva (); return new User ($ risultato);) / ** * Controlla se tale utente esiste nel database e restituisce il valore booleano di la variabile * @param stringa $ email. Indirizzo email personalizzato * @return boolean * / esiste una funzione pubblica statica ($ email) (// L'utente esiste nel database? $ Risultato = ORM :: for_table ("reg_users") -> dove ("email", $ email ) -> count (); return $ risultato == 1;) / ** * Crea un nuovo oggetto personalizzato * @param istanza $ param ORM, id, email o 0 * @return User * / public function __construct ($ param = null) (if ($ param instanceof ORM) (// Controllo ORM superato $ this-> orm = $ param;) else if (is_string ($ param)) (// Controllo email superato $ this-> orm = ORM :: for_table ("reg_users") -> dove ("email", $ param) -> find_one ();) else ($ id = 0; if (is_numeric ($ param)) (// il valore del $ param $ id la variabile viene passata all'ID utente = $ param;) else if (isset ($ _ SESSION ["loginid"])) (// Altrimenti watch session $ id = $ _SESSION ["loginid"];) $ this-> orm = ORM :: for_table ("reg_users") -> dove ("id", $ id) -> find_one ();)) / ** * Genera nuovo token di autorizzazione SHA1, scrive nella base e restituisce il suo valore * @return string * / public function generateToken() (// Genera un token per l'utente autorizzato e salvalo nella base $ token = sha1 ($ this-> email.time (). rand (0, 1000000 )); // Salva il token nel database // E contrassegnalo come valido solo per i prossimi 10 minuti $ this-> orm-> set ("token", $ token); $ this-> orm-> set_expr ("token_validity", "ADDTIME (ORA ()," 0:10 ")"); $ this-> orm-> save (); restituire il token $; ) / ** * Autorizza l'utente * @return void * / public function login () (// Contrassegna l'utente come autorizzato $ _SESSION ["loginid"] = $ this-> orm-> id; // Aggiorna il valore di il campo base last_login $ this-> orm-> set_expr ("last_login", "NOW ()"); $ this-> orm-> save ();) / ** * Distrugge la sessione e disconnette l'utente * @ return void * / public function logout () ($ _SESSION = array (); unset ($ _ SESSION);) / ** * Controlla se l'utente è connesso * @return boolean * / public function loggato () (return isset ($ this-> orm-> id) && $ _SESSION ["loginid"] == $ this-> orm-> id;) / ** * Controlla se l'utente è un amministratore * @return boolean * / public function isAdmin () (return $ this-> rank () = = "administrator";) / ** * Trova il tipo di utente, può essere amministratore o normale * @return string * / public function rank () (if ($ this -> orm-> rank == 1) (return "administrator";) return" regular ";) / ** * Metodo per ottenere informazioni private username as * proprietà dell'oggetto User * @param string $ key Nome della proprietà a cui si accede * @return mixed * / public function __get ($ key) (if (isset ($ this-> orm -> $ key)) ( restituisce $ questo -> orm -> $ chiave; ) restituisce nullo; ))

I token vengono generati utilizzando l'algoritmo SHA1 e archiviati nel database. Sto usando le funzioni di temporizzazione di MySQL per impostare un limite di scadenza del token di 10 minuti.

Quando un token supera la procedura di validazione, diciamo direttamente al gestore che consideriamo solo i token non ancora scaduti, archiviati nella colonna token_validity.

Si prega di notare che sto usando il metodo magico __ottenere la libreria docs alla fine del file per intercettare le proprietà dell'oggetto User.

Grazie a questo, diventa possibile accedere alle informazioni memorizzate nel database, grazie alle proprietà $ utente-> email, $ utente-> token e altri Nel seguente frammento di codice, prenderemo in considerazione, ad esempio, come utilizzare queste classi.

Pagina protetta

Un altro file che memorizza funzionalità utili e necessarie è il file functions.php... Ci sono diversi cosiddetti helper qui - funzioni di helper che ti permettono di creare codice più pulito e leggibile in altri file.

functions.php

Funzione send_email ($ da, $ a, $ oggetto, $ messaggio) (// Helper invio email $ headers = "MIME-Version: 1.0". "\ R \ n"; $ headers. = "Content-type: text / pianura; set di caratteri = utf-8 "." \ r \ n "; $ intestazioni. =" From: ". $ da." \ r \ n "; return mail ($ a, $ oggetto, $ messaggio, $ intestazioni) ;) function get_page_url () (// Determina l'URL del file PHP $ url = "http". (vuoto ($ _ 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;) function rate_limit ($ ip, $ limit_hour = 20, $ limit_10_min = 10) (// Numero di tentativi di accesso nell'ultima ora a questo indirizzo IP $ count_hour = ORM: : for_table ("reg_login_attempt") -> dove ("ip", sprintf ("% u", ip2long ($ ip))) -> where_raw ("ts> SUBTIME (NOW ()," 1: 00 ")") -> count (); // Il numero di tentativi di accesso negli ultimi 10 minuti a questo indirizzo IP $ count_10_min = ORM :: for_table ("reg_login_attempt") -> dove ("ip", sprint f ("% u", ip2long ($ ip))) -> where_raw ("ts> SUBTIME (NOW ()," 0:10 ")") -> count (); if ($ count_hour> $ limit_hour || $ count_10_min> $ limit_10_min) (genera una nuova eccezione ("Troppi tentativi di accesso!");)) function rate_limit_tick ($ ip, $ email) (// Crea un nuovo record nella tabella che legge il numero di tentativi di accesso $ login_attempt = ORM :: for_table ("reg_login_attempt") -> create (); $ login_attempt-> email = $ email; $ login_attempt-> ip = sprintf ("% u", ip2long ($ ip )); $ login_attempt-> save ();) funzione di reindirizzamento ($ url) (header ("Location: $ url"); uscita;)

Funzioni rate_limit e rate_limit_tick tenere traccia del numero di tentativi di autorizzazione nel periodo di tempo trascorso dal primo tentativo. Il tentativo di accesso viene registrato nel database nella colonna reg_login_attempt. Queste funzioni vengono chiamate quando i dati del modulo vengono elaborati e inviati, come puoi vedere dal seguente frammento di codice.

Il codice qui sotto è preso dal file index.php e gestisce l'invio del modulo. Restituisce una risposta JSON, che a sua volta viene elaborata da jQuery in un file asset / js / script.js, che abbiamo già analizzato in precedenza.

index.php

Try (if (! Empty ($ _ POST) && isset ($ _ SERVER ["HTTP_X_REQUESTED_WITH"])) (// Visualizza un'intestazione di intestazione JSON ("Content-type: application / json"); // È questo indirizzo email valid if (! isset ($ _ POST ["email"]) ||! filter_var ($ _ POST ["email"], FILTER_VALIDATE_EMAIL)) (genera una nuova eccezione ("Si prega di inserire una email valida.");) // Verifica. L'utente è autorizzato ad accedere, ha superato il numero di connessioni consentite? (file Functions.php per ulteriori informazioni) rate_limit ($ _ SERVER ["REMOTE_ADDR"]); // Registra questo tentativo di autorizzazione rate_limit_tick ($ _ SERVER ["REMOTE_ADDR"], $ _POST ["email"]); // Invia email all'utente $ messaggio = ""; $ email = $ _POST ["email"]; $ soggetto = "Your Login Link"; if ( ! Utente :: esiste ($ email) ) ($ soggetto = "Grazie per esserti registrato!"; $ messaggio = "Grazie per esserti registrato al nostro sito! \ n \ n";) // Tentativo di autorizzare o registrare un utente $ user = User :: loginOrRegister ($ _ POST [ "email"]); $ message. = "Puoi accedere da questo URL: \ n" ; $ messaggio. = get_page_url (). "? tkn =". $ user-> generateToken (). "\ n \ n"; $ message. = "Il collegamento scadrà automaticamente dopo 10 minuti."; $ risultato = send_email ($ fromEmail, $ _POST ["email"], $ oggetto, $ messaggio); if (! $ risultato) (genera una nuova eccezione ("Si è verificato un errore durante l'invio della tua email. Riprova.");) die (json_encode (array ("messaggio" => "Grazie! Abbiamo \" inviato un collegamento nella tua casella di posta. Controlla anche la cartella dello spam. ")));)) catch (Exception $ e) (die (json_encode (array (" error "=> 1," message "=> $ e-> getMessage () )));)

Dopo l'avvenuta autorizzazione/registrazione, il codice sopra invierà all'utente un link di autorizzazione. Il token diventa disponibile perché viene passato come variabile nel collegamento generato dal metodo $ _GET con marcatore tkn

index.php

If (isset ($ _ GET ["tkn"])) (// Questo token è valido per l'autorizzazione? $ User = User :: findByToken ($ _ GET ["tkn"]); if ($ user) (// Sì, è .Redirect alla pagina protetta $ user-> login (); redirect ("protected.php");) // No, il token non è valido.Reindirizza alla pagina con il modulo di autorizzazione/registrazione redirect (" index.php ");)

$ utente-> login ()

creerà le variabili necessarie per la sessione, in modo che l'utente, visualizzando le pagine successive del sito, rimanga sempre loggato.

La funzione di logout viene gestita in modo simile.

index.php

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

Alla fine del codice, ho reindirizzato nuovamente a index.php, quindi il parametro ? disconnettersi = 1 passato per URL non è richiesto.

Il nostro file index.php richiede ulteriori protezione - non vogliamo che le persone che hanno mai effettuato l'accesso al sistema vedano di nuovo il modulo di registrazione. Per questi scopi, usiamo il metodo $ utente-> accesso ().

index.php

$ utente = nuovo utente (); if ($ utente-> loggato ()) (redirect ("protected.php");)

Infine, ecco un pezzo di codice che ti permette di proteggere le pagine del tuo sito e renderlo disponibile solo previa autorizzazione.

protetto.php

// Per proteggere ogni pagina del tuo sito, includi il file // main.php e crea un nuovo oggetto Utente. Com'è facile! require_once "include /main.php"; $ utente = nuovo utente (); if (! $ utente-> loggato ()) (reindirizza ("index.php");)

Dopo questo controllo, puoi essere certo che l'utente è stato autorizzato con successo. Puoi anche accedere alle informazioni memorizzate nel database usando le proprietà dell'oggetto $ utente... Per visualizzare l'e-mail e lo stato di un utente, utilizza questo codice:

Echo "La tua email:" $ Utente-> email; echo "Il tuo grado:". $ utente-> grado ();

Metodo rango () utilizzato qui perché i numeri sono solitamente memorizzati nel database (0 per un utente normale, 1 per un amministratore) e abbiamo bisogno di convertire questi dati negli stati a cui appartengono, che è ciò in cui questo metodo ci aiuta.

Per rendere un utente normale un amministratore, è sufficiente modificare la voce dell'utente tramite phpMyAdmin (o qualsiasi altro programma che ti permetta di gestire i database). Lo stato di amministratore non fornisce alcun privilegio, in questo esempio, la pagina mostrerà che sei un amministratore, tutto qui.

Ma cosa fare con questo dipende da te, puoi scrivere e comporre tu stesso il codice che imposta determinati privilegi e capacità per gli amministratori.

Sono stati fatti!

Abbiamo finito con questa forma incredibilmente super quasi semplice! Puoi usarlo nei tuoi siti PHP, è piuttosto semplice. Inoltre, puoi modificarlo per te stesso e renderlo come desideri.

Il materiale è stato preparato da Denis Malyshok appositamente per il sito del sito

P.S. Vuoi andare avanti con la tua esperienza PHP e OOP? Dai un'occhiata ai tutorial premium su vari aspetti della creazione di siti, inclusa la programmazione in PHP, nonché il corso gratuito sulla creazione da zero del tuo sistema CMS in PHP utilizzando OOP:

Ti è piaciuto il materiale e vuoi ringraziarti?
Basta condividere con i tuoi amici e colleghi!

Quindi, c'è un compito: effettuare la registrazione nel sistema e la possibilità di autorizzazione. Come farlo? Cominciamo con ordine.

Registrazione Php

Tutto è semplice qui. È in corso la creazione di un data warehouse per gli utenti. Di solito è una tabella di database. Include campi come ID, nome utente e password. Gli altri campi sono facoltativi. Puoi raccogliere le e-mail degli utenti, i loro indirizzi, eventuale ip, ora di accesso alla rete, parole in codice da carte bancarie, domande segrete ...

In generale, la cosa principale è una coppia login-password.

Il primo punto importante- non è possibile memorizzare le password utente in chiaro. Cioè, come il testo. È impossibile perché se qualcun altro ottiene l'accesso al database, riceverà un database di password e nome utente, che è improbabile che gli piaccia. E se si tiene conto del fatto che la password di accesso per molti utenti su servizi diversi è la stessa, ciò mette a rischio i dati personali, le finanze, la corrispondenza personale e qualsiasi altra cosa.

Le password devono essere memorizzate come hash. HashingÈ un'operazione che trasforma i dati originali in una sorta di cast di lunghezza nota. Questo è un bene perché il cast è unico. Cioè, se cambiamo almeno un carattere nei dati originali, l'istantanea all'uscita dell'operazione di hashing risulterà completamente, irriconoscibile da altri. L'operazione di hashing è irreversibile, ovvero non sarà possibile espandere i dati originali da questo nugget. Ecco come si differenzia dalla crittografia.

MySQL e php condividono la stessa funzione di hashing comune e sicura: md5. Questo algoritmo prende i dati e produce un'impronta digitale.

Quindi, riceviamo i dati dall'utente, controlliamo se sono vuoti, se non contengono caratteri non necessari (non limitare troppo gli utenti). E ora facciamo una richiesta come questa:

INSERT INTO `users` (` id`, `username`,` password`) VALUES ("", $ quoted_username, MD5 ($ quoted_password));

Nota: ho specificamente chiamato le variabili $ quoted_ perché prima di inserirle nella query, devono essere sfuggite utilizzando la funzione mysql_real_escape_string (). Poiché questa funzione è usata molto spesso ed è scritta molto a lungo (adoro gli architetti pkhp), consiglio di stiparla nella shell. Ad esempio, in questo modo:

Citazione della funzione ($ var) (restituisce mysql_real_escape_string ($ var);)

Accesso php

Abbiamo aggiunto un nuovo utente e ora è autorizzato. Gli disegniamo un modulo di accesso-password e catturiamo i suoi dati. Qual è il prossimo? Dopotutto, la password ci è arrivata in chiaro e nel database: l'hash della password. Devi convertire la password in un hash, quindi confrontarli? No, puoi farlo più facilmente - in un'unica richiesta.

SELECT * FROM `users` WHERE` login` = $ qoted_login AND `password` = MD5 ($ quoted_password);

Se la richiesta restituisce una stringa, sarà una stringa con i dati dell'utente. In caso contrario, nella tabella non è presente tale utente. I dati dell'utente sono molto utili per noi: vale la pena inserirli in un array associativo.

Ricorda utente

Ora dobbiamo ricordare che l'utente è autorizzato e sa esattamente chi è. La prima cosa che viene in mente è usare i cookie per questo. Infatti - per stipare il nome utente e l'id dell'utente nel cookie e sapere sempre chi sta richiedendo la pagina in questo momento.

Ma questa è una pratica viziosa. Come mai? Perché un cookie è un file che viene memorizzato dall'utente nel browser e i dati di questo file vengono trasmessi al server in ogni richiesta. Innanzitutto, vengono trasmessi come testo, il che significa che sono facili da intercettare. In secondo luogo, è un semplice testo inviato dall'utente. Pertanto, può essere letteralmente riscritto. Ad esempio, se decidiamo di memorizzare il nome utente "Vasya" nei cookie, può aprire la gestione dei cookie nel suo browser, trovare il cookie desiderato e fissarlo, ad esempio, "Admin". E questo è tutto. Ora, ad ogni richiesta, riceveremo un cookie, che ci dirà il nome utente dell'utente - "Admin".

Pertanto, è più sicuro archiviare tutti i dati su un server in un luogo inaccessibile dal web. In qualche cartella a cui non è possibile accedere dal browser. In questa cartella è necessario scrivere tutti i dati dell'utente e leggerli da lì ogni volta che richiede un documento. Per scoprire quale utente possiede quale file di dati, è necessario chiamare il file con un nome univoco e inserire questo nome nel cookie per l'utente. Pertanto, l'utente non sarà in grado di scoprire come viene chiamato il file per l'utente Admin: questo file viene generato dal sistema sul server. E questo ti permette di trascinare da un documento all'altro anche password chiare.

Quello che ho descritto è meccanismo di sessione... In Perl, ad esempio, è necessario caricare i moduli per utilizzare le sessioni. E in php, le sessioni sono supportate immediatamente. In effetti, tutto ciò che devi sapere è la funzione session_start() e l'array $ _SESSION. È tutto. Te lo dico adesso.

In ogni script in cui scriverai o leggerai da una sessione, è necessario prima di visualizzare qualsiasi informazione chiama la funzione session_start(). Questo avvierà la sessione. Questa funzione creerà un file di sessione se non esiste, o lo leggerà se un cookie speciale è stato passato allo script.

Per scrivere i dati nella sessione, è sufficiente scriverli nell'array $ _SESSION. Ora dobbiamo ricordare l'id dell'utente.

$ _SESSION ["id utente"] = $ infoutente ["id"];

Qualunque cosa. Ora, ogni volta che un utente richiede uno script che utilizza sessioni, il valore dell'elemento $ _SESSION ["userid"] sarà disponibile per te.

Pertanto, quando l'utente ha inserito il login e la password, abbiamo ricevuto i suoi dati dal database, il che conferma che tale utente è nel nostro database, lo ricordiamo nella sessione.

Scopri se l'utente è autorizzato

Bene, è facile come sgusciare le pere! Ora che sai come funzionano le sessioni, scoprire se un utente ha effettuato l'accesso è questione di una riga. Eccola:

If (isset ($ _ SESSION ["userid"])) (print "utente autorizzato";)

Se un ID utente è definito nella sessione, allora ha già superato l'autorizzazione. Ma come fai a sapere che utente è? Qual è il suo nome utente? Data di nascita? Parola in codice per una carta bancaria? Cognome della madre da nubile?

Bene, ovviamente, fai una query alla tabella degli utenti. Abbiamo l'id di questo utente.

SELECT * FROM `users` WHERE` id` = $ quoted_userid

Come disconnettere un utente, disconnettersi

Beh, è ​​davvero molto semplice. Se determiniamo se un utente è autorizzato dalla presenza di un ID utente nella sessione, per disconnetterlo, dobbiamo eliminarlo da lì. Si fa così:

Unset ($ _ SESSIONE ["userid"]);

Puoi anche interrompere la sessione per fedeltà. Questo cancellerà il cookie dell'utente e distruggerà il file di sessione sul server. In questo caso, tutti i dati andranno persi da esso. Si fa così:

Session_destroy ();

È tutto. Se hai domande, non esitare a contattarci. Inoltre, puoi contattarmi tramite icq o mail e chiedere aiuto per qualcosa. Di solito non mi rifiuto. Se è necessario un aiuto serio, posso chiedere un piccolo pagamento. Inoltre, posso insegnarti come realizzare siti web da remoto! Ecco come sono un coach e un guru :) E se vuoi ricevere lezioni e trucchi gratis, iscriviti all'RSS del mio blog.

Lo sponsor di questo post è ibooknet.ru, che offre riparazioni di laptop a prezzi convenienti. Personalmente, il mio laptop va bene e spero di non doverlo riparare. Che è quello che ti auguro.

Ciao a tutti. Quindi, abbiamo coperto alcuni elementi per la creazione di moduli. È tempo di unire le nostre conoscenze per risolvere un problema più grande. Creiamo il modulo più semplice per l'autorizzazione sul sito. Per fare ciò, abbiamo bisogno di due campi, creiamo e leghiamo le firme ad essi.

Il primo campo è per il login, il secondo è per la password. E con il secondo, non tutto è così semplice. Dal momento che al momento è solo un campo per l'inserimento di testo.

Login
Parola d'ordine

Risultato nel browser:

Affinché il testo inserito in esso venga sostituito con asterischi, come è consuetudine per un campo di questo tipo, è necessario eseguire una semplice azione. Vale a dire, sostituire il valore dell'attributo genere sul parola d'ordine:

Risultato:

Pulsante di invio modulo

Ecco qui. Il nostro modulo è quasi pronto. Ora, per completare la sua creazione, è necessario creare un pulsante che verrà utilizzato per inviare il modulo. Il compito è risolto usando il tag con tipo Invia.

Se dovrebbe esserci qualche tipo di iscrizione sul pulsante, allora può essere fatto usando l'attributo valore... Sta a te specificare o meno un nome per il pulsante, quindi se lo fai, il server riceverà questo nome, così come il valore del pulsante.

Di norma, è necessario il nome del pulsante di invio del modulo quando il modulo ha diversi pulsanti, ognuno dei quali esegue un'azione specifica. Grazie a ciò, il server, ricevendo il nome e il valore del pulsante dal browser, capisce quale pulsante l'utente ha premuto e cosa, di conseguenza, deve essere fatto.

Di conseguenza, il codice per il nostro modulo sarà simile a questo:

Login
Parola d'ordine

Risultato nel browser:

La funzione di registrazione e autorizzazione degli utenti al sito è implementata come segue: quando un utente si registra al sito, compila un modulo di registrazione, nel quale indica vari dati, tra cui login e password. Il modulo invia questi dati al server e viene scritto nel database.

1. L'utente inserisce il login e la password nel modulo di autorizzazione e lo invia al server.
2. Il server controlla se c'è un utente nel database con questo nome utente e password.
3. Se l'utente viene trovato, le informazioni al riguardo vengono registrate nella sessione o nei cookie.
4. Sulle pagine del sito, c'è un controllo: ci sono dati nella sessione che l'utente è autorizzato e, a seconda di ciò, la pagina viene visualizzata in una forma o nell'altra.

Nella sessione è possibile non solo indicare il fatto di autorizzazione, ma anche scrivere alcuni dati dell'utente per visualizzarli nella pagina, ad esempio un nome o un nickname. La decisione se utilizzare sessioni o cookie viene presa sito per sito. Se il sito contiene informazioni importanti, è meglio utilizzare le sessioni, perché è molto più difficile scoprire i dati di registrazione di qualcun altro.

Moduli di autorizzazione e registrazione

Il modulo di autorizzazione si trova solitamente nella pagina principale, oppure può trovarsi in tutte le pagine del sito. Fondamentalmente, viene creata una pagina separata per il modulo di registrazione. Creeremo solo una pagina, su cui saranno entrambi i moduli, e su di essa verranno visualizzati i dati dell'utente. Finora conterrà solo codice HTML, ma creeremo immediatamente un file PHP, perché in futuro sarà uno script. Chiamiamolo formreg.php. Il codice della pagina sarà così:

formreg.php:

registrazione

Registreremo i dati di registrazione degli utenti nella tabella degli utenti. Se non hai ancora una tabella del genere, creala. Dovrebbe contenere i campi id, login e pas. Non useremo altri campi. Se sono nella tabella, rimarranno vuoti.

registrazione.php:

3 4 5 6 7 8 9 10

$ login = $ _ POST ["accesso"]; $ pas = $ _ POST ["password"]; $ db = mysqli_connect ("localhost", "root", "", "mybase"); $ query = "INSERT INTO users (login, pas) VALUES (" $ login "," $ pas ")"; $ risultato = mysqli_query ($ db, $ query); if ($ risultato) intestazione ("Location: formreg.php"); mysqli_close ($ db);

Sulla riga 9, impostiamo il ritorno alla pagina del modulo. Poiché sul server locale l'esecuzione dello script e il ricaricamento della pagina sono molto veloci, visivamente sembrerà che non accada nulla quando si fa clic sul pulsante "Registrati". Sui siti reali, di solito vanno a una pagina speciale con le informazioni che l'utente è registrato e i dati di registrazione. Prova a registrarti e vedi se compaiono nuovi record nel database.

Autorizzazione

Il modulo di autorizzazione esegue il file authorization.php sul server. Questo script accetta login e password e controlla se esiste un tale utente. In tal caso, il login verrà registrato nella sessione. Se tale utente non viene trovato, le informazioni su questo verranno registrate nella sessione. Ciò è necessario affinché la pagina che verrà aperta dopo l'esecuzione dello script riceva queste informazioni e visualizzi un messaggio che indica che è stato inserito un nome utente o una password errati. Il codice dello script è così:

autorizzazione.php:

3 4 5 6 7 8 9 10 11 12 13 14

inizio_sessione (); $ login = $ _ POST ["accesso"]; $ pas = $ _ POST ["password"]; $ db = mysqli_connect ("localhost", "root", "", "mybase"); $ query = "SELECT * FROM utenti WHERE login =" $ login "AND BINARY pas =" $ pas ""; $ risultato = mysqli_query ($ db, $ query); if (mysqli_num_rows ($ risultato)) $ _SESSION ["login"] = $ login; else $ _SESSION ["login"] = "er login"; intestazione ("Posizione: formreg.php"); mysqli_close ($ db);

Nella riga 7, viene formata una richiesta per selezionare una riga con login e password ottenuti dal modulo. La parola chiave BINARY è scritta davanti al campo pas. È necessario affinché il confronto su questo campo faccia distinzione tra maiuscole e minuscole. Se vuoi fare distinzione tra maiuscole e minuscole quando confronti il ​​login, allora BINARY deve essere scritto prima di esso. L'esempio richiede di selezionare tutti i campi. In pratica si possono selezionare solo quei campi i cui dati dovranno essere visualizzati nella pagina.

Dopo aver ricevuto il risultato, viene verificato se viene trovato il record specificato. Se è presente un record, l'accesso viene registrato nella sessione. Se l'utente non viene trovato, al posto del login viene scritta la stringa "er login". Puoi scrivere un altro testo, ma devi essere sicuro che non coincida con qualche login. Poi c'è un ritorno alla pagina con i moduli.

Sulle pagine del sito dovrebbe essere presente un codice che verifica se c'è un login nella sessione. E a seconda di ciò, viene determinato come dovrebbe apparire la pagina. Nel nostro esempio, c'è solo una pagina. Lo verificheremo su di esso. Solo il codice sarà diviso in due parti. La sessione deve essere aperta prima dell'output di qualsiasi dato, ovvero prima del codice HTML. Pertanto, questa parte si trova all'inizio della pagina. E il resto del codice è all'interno del tag perché aggiunge contenuto alla pagina. Aggiungi la seguente riga nella parte superiore della pagina:

Se la sessione ha un login, ma contiene la stringa "er login", viene visualizzato un messaggio che il login o la password non sono corretti. Dopo aver visualizzato il messaggio, il login diventa vuoto. Questo viene fatto in modo che il messaggio venga visualizzato una sola volta e non compaia durante la navigazione in altre pagine. Se il login è diverso, allora l'utente è autorizzato e la pagina è formata come per quelli registrati. Se non c'è accesso, allora non c'era ancora l'autorizzazione e la pagina viene visualizzata per gli utenti non registrati.

Abbiamo considerato solo il principio generale della creazione della funzione di registrazione e autorizzazione. Sui siti reali, è più difficile. I moduli devono essere visualizzati solo per utenti non autorizzati. Inoltre, è necessario aggiungere un pulsante "Esci", che annulla l'autorizzazione. Al momento della registrazione, è necessario controllare il modulo, verificare l'unicità del login e aggiungere una conferma della password.