In questo articolo vogliamo introdurre i lettori ai concetti fondamentali riguardanti la gestione degli utenti all'interno di un sito web o di un'applicazione internet. Tratteremo argomenti relativi all'autenticazione, alla gestione dei permessi, alla sicurezza ed alla registrazione, in modo da presentare un'analisi completa delle problematiche che si devono affrontare durante la stesura di un sistema simile.
Gli script proposti implementano una struttura procedurale abbastanza frammentata, in modo da permettere la semplice modifica per adattarli alle proprie esigenze.
Prima di iniziare esorto i lettori a leggere gli articoli riguardanti i Tutto sui cookie e le Sessioni alternative in Php presenti su HTML.it, anche se non essenziali per la corretta comprensione degli articoli.
Abbiamo racchiuso i file utilizzati in questo articoli in tre diversi archivi ZIP che corrispondono alle tre parti in cui è diviso questo articolo: uno relativo all'autenticazione, uno relativo alla registrazione e uno ai permessi. Tutti gli script sono stati comunque racchiusi anche in un unico archivio. Vanno tenuti presenti in modo particolare poiché faremo riferimento ad essi per ogni commento al codice interno all'articolo.
Nelle prime pagine dell'articolo svilupperemo un semplice sistema di autenticazione che permetterà di svolgere le seguenti operazioni:
- Eseguire i login per autenticarsi e visualizzare pagine private
- Effettuare il logout
- Mantenere informazioni sull'utente loggato attraverso l'utilizzo di cookie o link
Il sistema, una volta verificata la correttezza dei dati passati, inizializzerà una sessione all'interno del nostro database, ed utilizzerà un ID univoco come riferimento a questa. Questo ID verrà passato tra le pagine sfruttando o i cookie o la query string dell'URL, in base alle scelte del programmatore.
Prima di iniziare, prepariamo il nostro database: creiamo una tabella per gestire le sessioni con il seguente comando:
CREATE TABLE sessioni (
uid CHAR(32) NOT NULL,
user_id INT UNSIGNED NOT NULL,
creation_date INT UNSIGNED NOT NULL,
INDEX(uid)
);
La tabella sessioni contiene tre campi:
- Il campo uid conterrà l'ID univoco che identificherà la sessione di riferimento per un utente autorizzato. Verrà utilizzato per reperire l'ID dell'utente nella tabella 'utenti', e come controllo per sapere se l'utente è autorizzato o meno
- Il campo user_id conterrà l'ID della tabella 'utenti' al quale la sessione fa riferimento
- Il campo creation_date conterrà la data (espressa in secondi) di creazione della sessione; verrà utilizzato per controllare se la sessione è scaduta o meno.
Creiamo ora la tabella per salvare informazioni sugli utenti:
CREATE TABLE utenti (
id INT UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(30) NOT NULL,
surname VARCHAR(30) NOT NULL,
username VARCHAR(30) NOT NULL,
password CHAR(32) NOT NULL,
PRIMARY KEY(id),
INDEX(username, password)
);
La tabella utenti contiene cinque campi:
- Il campo id conterrà un numero univoco per identificare il record contenete i dati dell'utente loggato
- I campi name e surname conterranno rispettivamente nome e cognome dell' utente
- Il campo username conterrà il nome utente necessario per effettuare il login
- Il campo password conterrà la password (criptata attraverso la funzione MD5) che l'utente dovrà utilizzare per effettuare il login
Dato che il processo di registrazione verrà analizzato nei prossimi articoli, riempiremo ora la tabella utenti manualmente:
INSERT INTO utenti (name, surname, username, password) VALUES ('Gabriele', 'Farina','darkbard',MD5('test'));
INSERT INTO utenti (name, surname, username, password) VALUES ('Fabio', 'Sutto','fabio heller',MD5('test2'));
INSERT INTO utenti (name, surname, username, password) VALUES ('Giancarlo', 'Moschitta','gm',MD5('test3'));
L'unica cosa da appuntare è l'utilizzo della funzione MD5 (facente parte del core di funzioni di MySQL): data una stringa in input, questa funzione restituisce un valore di 32 bit irreversibile che rappresenta univocamente la stringa data. Salvando nel database le password attraverso MD5 aumentiamo leggermente la sicurezza: difatti, anche avendo accesso manuale al database, non si avrà alcun modo per conoscere la password relativa ad un dato utente.
Autenticazione
La semplice applicazione che creeremo avrà la seguente struttura nel filesystem:
autenticazione
|
+--- Directory: include
| |
| +--- File: config.php
| |
| +--- File: auth.lib.php
|
+--- File: home.php
|
+--- File: login.php
|
+--- File: logout.php
|
+--- File: pagina1.html
|
+--- File: pagina2.php
|
+--- File: pagina3.php
|
+--- File: pagina4.phpCominciamo creando il file di configurazione (config.php): questo file conterrà alcune costanti predefinite che utilizzeremo all'interno dei nostri script (il loro significato vi verrà spiegato in seguito), i parametri di connessione al DB, alcune opzioni e le funzioni per effettuare la connessione a MYSQL. Nel file config.php contenuto nella cartella include potete visualizzare il codice necessario.
Continuiamo iniziando a scrivere il file auth.lib.php, che conterrà tutte le funzioni che utilizzeremo per effettuare il processo di autenticazione dell'utente. Sempre per motivi di spazio, non vi mostro il listato del codice, che potete comunque trovare all'interno del file auth.lib.php nella cartella include.
Questa libreria implementa le funzionalità necessarie affinché il nostro script sia capace di autenticare un utente. Vediamola in dettaglio.
L'array $_AUTH contiene le opzioni capaci di cambiare il comportamento della libreria. Per ora solo un'opzione è stata inserita che serve ad identificare il metodo con il quale passare tra le varie pagine l'ID di sessione; le opzioni possibili sono AUTH_USE_LINK, AUTH_USE_COOKIE. Lascio a voi la modifica della libreria per permettere la gestione dell'ID tramite metodi alternativi. Questo array non verrà mai letto direttamente, ma utilizzeremo le funzioni auth_get_option() e auth_set_option(). In questo modo potremo implementare una gestione più completa delle opzioni, magari elaborando i dati presenti nell'array in caso di richieste particolari;
La funzione auth_clean_expired() viene utilizzata per eliminare le sessioni scadute precedentemente. Viene richiamata in ogni pagina dalla funzione auth_get_status(). L'eliminazione della sessione avviene semplicemente eliminando dal database i record relativi a sessioni scadute, ed eliminando l'ID di riferimento salvato.
La funzione auth_get_uid() restituisce l'ID univoco relativo alla sessione corrente. Preleva l'ID in base al valore dell'opzione TRANSICTION METHOD
auth_get_status() viene utilizzata per prelevare un array di due valori avente come primo valore lo stato dell'utente che sta navigando la pagina e come secondo una lista di informazioni relative all'utente, in caso questi sia connesso. Per prima cosa vengono eliminate le sessioni scadute, poi viene recuperato l'ID univoco. Se questo non è presente, significa che l'utente non ha ancora effettuato il login o che la sua sessione è scaduta. Se invece esiste, vengono prelevate dal database le informazioni relative all'utente e restituite.
auth_login() effettua il login: accetta come parametri l'username e la password esegue una query di selezione per controllare che i dati permettano il login di un utente. In caso affermativo restituisce lo status AUTH_LOGEDD_IN ed i dati dell'utente, in caso negativo restituisce AUTH_INVALID_PARAMS e nessun altra informazione.
auth_generate_uid() genera un ID univoco di 32 caratteri, sfruttando funzioni builtin di PHP.
auth_register_session() accetta come parametri i dati di un utente che si suppone autenticato precedentemente, e genera una nuova sessione; inserisce nella tabella delle sessioni le informazioni necessarie, e restituisce un array: in caso l'operazione sia andata a buon fine restituirà lo status AUTH_LOGEDD_IN e l'ID della sessione, altrimenti AUTH_FAILED e null'altro.
L'ultima funzione, auth_logout(), esegue il logout dell'utente connesso, eliminando la sessione a lui riferita.
Applicare la libreria ad un caso reale
Dopo aver scritto la nostra libreria, non ci resta che testarla con un semplicissimo esempio. In questo esempio permetteremo ad un utente di navigare all'interno di della pagine, alcune private altre pubbliche, e di effettuare login e logout.
Il file presentati all'interno della cartella principale del file compresso contengono un semplice applicativo di esempio.
La libreria viene utilizzata per effettuare il login nel seguente modo:
<?php
include_once("include/config.php");
include_once("include/auth.lib.php");
list($status, $user) = auth_get_status();
if($status == AUTH_NOT_LOGGED){
$uname = strtolower(trim($_POST['uname']));
$passw = strtolower(trim($_POST['passw']));
if($uname == "" or $passw == "") $status = AUTH_INVALID_PARAMS;
else{
list($status, $user) = auth_login($uname, $passw);
if(!is_null($user)) list($status, $uid) = auth_register_session($user); }
}
switch($status){
//... controllare nel file login.php per il codice completo
}
?>
Dopo aver controllato che lo status dell'utente non corrisponda ad AUTH_LOGGED, e dopo aver controllato che entrambi i dati passati tramite POST siano corretti, richiamiamo le funzioni auth_login() ed auth_register_session() per eseguire il login e registrare una nuova sezione. Il grosso switch presente alla fine della pagina controlla il valore della variabile $status (che rappresenta lo stato in cui lo script è terminato), e visualizza un messaggio all'utente. Con questo metodo possiamo gestire varie possibilità molto semplicemente.
Oltretutto in ogni pagina privata è presente un semplice controllo sullo stato dell'utente che sta navigando attualmente (prelevato sempre attraverso auth_get_status() ). In caso lo stato sia AUTH_LOGGED sappiamo che l'utente è loggato e possiamo permettergli di visualizzare i dati della pagina, altrimenti no .
Registrazione
In questa parte descriveremo il processo di registrazione di un nuovo utente. Il sistema che svilupperemo sarà strutturato in modo da eseguire le seguenti operazioni:
- Effettuare un controllo sui campi compilati, in modo da riportare all'utente eventuali errori di compilazione
- Richiedere una conferma via email all'utente, al fine di valicare i dati inseriti (nello script l'indirizzo email non verrà salvato nel database. Potrete comunque decidere di farlo apportando poche ed intuitive modifiche allo script)
- Impedire l'accesso agli utenti registrati ma che non hanno ancora confermato i loro dati
Vedremo le modifiche da apportate ad ogni file trattao nelle pagine precedenti e spiegheremo la struttura dei nuovi script aggiunti.
Prima di addentrarci nel codice PHP, apportiamo delle modifiche alla tabella utenti in modo da renderla adatta a gestire il nostro processo di autenticazione:
ALTER TABLE utenti
ADD indirizzo VARCHAR( 100 ) NOT NULL,
ADD occupazione VARCHAR( 100 ) NOT NULL,
ADD temp SET( '0', '1' ) NOT NULL,
ADD regdate VARCHAR( 11 ) NOT NULL,
ADD uid VARCHAR( 32 ) NOT NULL;
I primi due campi aggiunti sono due dati simbolici che rappresentano le informazioni necessarie affinché l'utente possa registrarsi. Potete aggiungerne altri, ma ricordate di apportare le modifiche necessarie ai file descritti in seguito.
Il campo temp contiene un valore pari a 1 in caso l'utente non abbia ancora confermato la registrazione, pari a 0 in caso contrario. Dato che un utente che non ha ancora confermato i dati non può effettuare il login, modifichiamo la query SQL eseguita dalla funzione auth_login all'interno del file auth.lib.php in questo modo:
$result = mysql_query("
SELECT *
FROM ".$_CONFIG['table_utenti']."
WHERE username='".$uname."' and password=MD5('".$passw."') and temp = '0'"
);
Il campo regdate conterrà l'istante in cui la registrazione è stata effettuata. Verrà utilizzato per rimuovere le registrazioni non ancora confermate e scadute.
Infine il campo uid conterrà un indice univoco che utilizzeremo per la conferma della registrazione.
Aggiungiamo alla tabella dei link all'interno del file home.php un riferimento al form di registrazione:
<td><a href="registrati.php">Registrati</a></td>
La libreria di registrazione
La libreria per la registrazione che ci accingiamo a scrivere conterrà funzioni utili per il controllo, il salvataggio e la validazione dei dati. Il codice sorgente può essere prelevato dal file reg.lib.php all'interno della cartella include.
La funzione reg_register accetta come parametro un array associativo contenete i dati dell'utente: dopo aver prelevato un indice univoco necessario per la successiva conferma dei dati, la funzione inserisce un nuovo record all'interno del database ed invia una mail all'utente attraverso un'altra funzione di libreria; come potete notare il campo temp è settato automaticamente a 1, in modo da impedire il login dell'utente finché questi non avrà confermato i suoi dati.
La funzione successiva, reg_send_confirmation_mail, accetta come parametri l'indirizzo dell'utente, l'indirizzo di provenienza della mail e l'id univoco, e si pone il compito di inviare una mail all'utente contenete il link alla pagina di conferma.
reg_clean_expired ripulisce la tabella utenti dalle registrazioni scadute, basandosi sui dati presenti nel file di configurazione. reg_get_unique_id genera un indice univoco, utilizzato per la conferma.
La funzione reg_check_data viene utilizzata per effettuare un controllo sui dati inseriti dall'utente; per ogni dato presente all'interno dell'array passato come argomento, questa funzione richiama una callback associata precedentemente all'interno del file di configurazione, la quale si occuperà di validare o meno il dato; nel caso in cui siano stati riscontrati errori, questa funzione li restituirà al blocco di codice chiamante, in modo che questi possa gestirli correttamente.
L'ultima funzione presente all'interno del modulo, reg_confirm, è quella che effettua la conferma dei dati, modificando il valore del campo temp nella tabella utenti in base al parametro passatole.
Come possiamo notare anche questo modulo è molto semplice e compatto, e contiene tutte le operazioni necessarie a soddisfare gli obiettivi che ci eravamo posti all'inizio dell'articolo.
Non ci resta che adattare gli altri script alla nuova libreria.
Il file di configurazione ed il modulo di registrazione
Il file config.php contenuto nella cartella include è stato leggermente modificato in modo da supportare la libreria di registrazione.
È stato aggiunto il parametro di configurazione regexpire che rappresenta il numero di ore dopo le quali una registrazione non confermata sarà dichiarata scaduta.
Il parametro check_table è invece un array associativo strutturato in modo da associare ad ogni chiave, rappresentante un campo del form di registrazione, una funzione che ne controlli il valore. Questa funzione di callback accetta come parametro il valore del campo, e restituisce true in caso di successo, oppure una stringa che rappresenta il valore testuale dell'errore. In caso un valore del form non sia presente come chiave dell'array, il valore viene interpretato automaticamente come corretto.
Le funzioni check_* sono quelle di callback. Per non allungare il codice inutilmente, ho associato la funzione check_global a quasi tutti i campi.
La struttura a callback permette di gestire facilmente l'aggiunta o la rimozione di campi all'interno del form di registrazione.
Sono state aggiunte anche tre costanti, caratterizzate dal prefisso REG_, utilizzate come valore di ritorno di alcune funzioni al fine di implementare un controllo degli stati simile a quello utilizzato durante la stesura dello script di autenticazione.
Il modulo di registrazione (contenuto nel file registrati.php) è un semplice form HTML contente un numero di campi pari ai valori necessari al fine di rendere la registrazione corretta.
In caso voleste aggiungere o rimuovere dei campi dal processo di registrazione, le operazioni da seguire sono le seguenti:
- Modificare la struttura della tabella utenti
- Aggiungere o togliere campi di input al modulo di registrazione
- Aggiungere o togliere valori dal parametro di configurazione check_table
- Modificare la query di inserimento presente all'interno della funzione reg_register
Registrazione e conferma dei dati
Il modulo di registrazione richiama la pagina register.php che si occupa di effettuare realmente la registrazione. La pagina ha il seguente contenuto:
<html>
<head>
<style type="text/css">
<!--
.style1 {
color: #FF0000;
font-weight: bold;
}
-->
</style>
</head>
<body>
<?php
include_once("include/config.php");
include_once("include/reg.lib.php");
if(isset($_POST['action']) and $_POST['action'] == 'Invia'){
$ret = reg_check_data($_POST);
$status = ($ret === true) ? reg_register($_POST) : REG_ERRORS;
switch($status){
case REG_ERRORS:
?>
<span class="style1">Sono stati rilevati i seguenti errori:</span><br>
<?php
foreach($ret as $error)
printf("<b>%s</b>: %s<br>", $error[0], $error[1]);
?>
<br>Premere "indietro" per modificare i dati
<?php
break;
case REG_FAILED:
echo "Registrazione Fallita a causa di un errore interno.";
break;
case REG_SUCCESS:
echo "Registrazione avvenuta con successo.<br>
Vi è stata inviata una email contente le istruzioni per confermare la registrazione.";
break;
}
}
?>
</body>
</html>
A parte l'ovvio codice HTML, possiamo notare che, dopo aver effettuato un controllo sul fatto che la pagina abbia ricevuto dei dati, lo script si occupa di controllare il valore dei dati ricevuti e di effettuare successivamente la registrazione. Il controllo della variabile $status permette di mostrare all'utente un output differente in base al risultato delle funzioni richiamate: ad esempio, in caso di errori, lo script si occupa di mostrare all'utente una lista contenete il nome del campo ed il valore dell'errore.
L'ultima pagina generata e non ancora trattata è confirm.php:
<?php
include_once("include/config.php");
include_once("include/reg.lib.php");
if(isset($_GET['id']) and strlen($_GET['id']) == 32){
reg_clean_expired();
$status = reg_confirm($_GET['id']);
switch($status){
case REG_SUCCESS:
echo "La tua registrazione è stata confermata; ora puoi effettuare il login.";
break;
case REG_FAILED:
echo "La registrazione non può essere confermata, probabilmente picchè è scaduta.";
break;
}
}
?>
Dopo aver controllato che sia stato passato un ID valido alla pagina tramite querystring, lo script rimuove le registrazioni scadute e richiede una conferma dei dati: in caso affermativo sarà concesso all'utente di effettuare il login, altrimenti verrà visualizzato un messaggio di errore
Permessi
Con quest'ultima parte concludiamo la mini-guida alla gestione degli utenti con PHP. Nelle prime tre pagine abbiamo iniziato strutturando il database e creando degli script che ci permettessero di gestire gli utenti con PHP (login, logout e sessioni). Successivamente, dalla pagina 4 alla pagina 6, abbiamo esteso l'esempio aggiungendo, senza troppe difficoltà data l'organizzazione procedurale dei file, un modulo che permettesse la registrazione di nuovi utenti.
In quest'ultima parte, infine, ci preoccuperemo di implementare degli script che rendano possibile la gestione di permessi relativi ad ogni utente, così da avere la possibilità di impedire o permettere l'esecuzione di alcune operazioni in base all'utente con il quale il server sta dialogando.
Esistono molti sistemi per gestire l'assegnazione di permessi agli utenti; io ho deciso di implementarne uno abbastanza semplice basato su operazioni binarie, che verrà descritto il più dettagliatamente possibile in questo articolo.
Impostare il progetto
Come negli altri articoli, prima di spiegare le modifiche fatte agli script, ci accingiamo ad eseguire semplici query SQL per rendere il database adatto a gestire le aggiunte. Eseguiamo le seguenti query:
ALTER TABLE utenti ADD permessi INT DEFAULT '0' NOT NULL ;
CREATE TABLE permessi (
id INT UNSIGNED NOT NULL ,
nome VARCHAR( 100 ) NOT NULL ,
descrizione TEXT NOT NULL ,
PRIMARY KEY ( id )
);
La prima query modifica la tabella utenti aggiungendole un campo permessi nel quale salveremo un intero che rappresenta i permessi associati al singolo utente. La seconda query si occupa di creare la tabella per la gestione dei permessi:
- il campo id conterrà un multiplo di due che indica in modo univoco il nostro permesso: utilizziamo un multiplo di due perché sfrutteremo le operazioni boolean AND ed OR sugli interi per controllare che un utente abbia i permessi adatti ad eseguire certe operazioni;
- il campo nome conterrà il nome del permesso: verrà utilizzato all'interno della semplice pagina di amministrazione che creeremo e come riferimento leggibile per il check;
- il campo descrizione conterrà la descrizione leggibile del permesso;
Dopo aver apportato le modifiche al database e dopo aver modificato leggermente il testo della pagina home.php (guardate il file omonimo per le semplicissime modifiche), ci apportiamo ad impostare la pagina di amministrazione: questa pagina ci permetterà di assegnare o togliere i permessi ad un dato utente e di crearne di nuovi; ho impostato la pagina in modo che abbia un aspetto simile a seguente:
la parte superiore permette la gestione dei permessi: possiamo modificare i permessi di un utente semplicemente selezionando o meno la checkbox relativa e ciccando sul pulsante modifica.
La parte inferiore permette di aggiungere un nuovo permesso nel database, semplicemente compilando i campi.
Le librerie license ed utils
Ora descriverò le librerie base che sfrutteremo all'interno dei nostri script per permettere la gestione dei permessi. La libreria contenuta nel file utils.lib.php è molto semplice:
<?php
function get_users_list(){
$result = mysql_query("
SELECT *
FROM utenti
WHERE temp='0'
");
$data = array();
while($tmp = mysql_fetch_assoc($result)){
array_push($data, $tmp);
};
return $data;
}
function user_get_id($user){
return mysql_result(mysql_query("
SELECT id
FROM utenti
WHERE username='".$user['username']."' and password='".$user['password']."'
"), 0, 'id');
}
?>
La funzione get_users_list restituisce una lista di tutti gli utenti registrati presenti all'interno del database. La funzione user_get_id accetta come parametro un array contente le informazioni relative ad un utente, e ne restituisce l'id.
La libreria contenuta nel file license.lib.php è invece leggermente più complicata, e contiene tutte le procedure necessarie a gestire i permessi:
- license_get_list restituisce la lista dei permessi registrati all'interno del database
- license_change modifica i permessi di un utente; accetta come parametri l'id dell'utente ed un numero che indica di quali permessi dispone
- license_new_id restituisce un nuovo id utilizzabile come numero univoco per indicare un permesso. La query SQL eseguita preleva l'id dell'ultimo permesso inserito e lo restituisce moltiplicato per due. In questo modo avremo sempre una potenza di due come numero identificativo, il che ci permetterà di controllare i permessi agilmente usando OR ed AND
- license_add aggiunge un nuovo permesso
- license_user_get_perms restituisce i permessi di un singolo utente
- license_has controlla che un utente abbia un dato permesso; accetta come parametri l'id dell'utente ed una stringa rappresentante il nome del permesso e controlla, dopo aver prelevato i permessi dell'utente e l'id del permesso preso in esame, che l'operazione boolean AND restituisca un valore vero
- license_get resituisce i permessi associati ad un dato utente, i cui dati sono passati come primo argomento
Urge una breve spiegazione delle operazioni boolene su multipli di due: i multipli di due, trasformati in numeri binari, assumono il seguente aspetto:
quando i numeri binari sono combinati attraverso le operazioni boolean AND ed OR, viene fatto un controllo booleano cifra per cifra nel seguente modo:
Come potete notare vengono svolte operazioni molto semplici:
- in caso di A|B il risultato avrà come cifra alla posizione N la combinazione booleana delle rispettive cifre dei valori A e B alla posizione N. Siccome questi valori sono 1 o 0, l'operazione è molto semplice
- in caso di A&B si controllerà che entrambi i valori siano pari ad 1
La spiegazione è purtroppo molto sommaria, ma in rete potrete trovare moltissime informazioni utili a riguardo.
La sezione di amministrazione
La sezione di amministrazione, contenuta nel file admin.php, è molto semplice da sviluppare: oltre al solito codice HTML per impaginare i dati, svolgiamo le seguenti operazioni:
- la tabella dei permessi è generata prelevando in modo incrociato tutti gli utenti e tutti i permessi da database. In caso un utente abbia un dato permesso la checkbox viene settata come checked, altrimenti no;
- I nomi assegnati alle checkbox sono degli array nella forma "u" + USER_ID + "[]", in modo da poter gestire agilmente i dati tramite PHP;
- In caso un untente prema il pulsante aggiungi, ci occupiamo di aggiungere un nuovo permesso PRIMA di generare la tabella del primo punto;
- In caso un untente prema modifica, eseguiamo un controllo su tutti li array che iniziano per "u" e salviamo i dati relativi ad ogni utente.
Spostando il mouse sopra il nome di un permesso,ne visualizzeremo la descrizione.
Come potete notare la zona di amministrazione è molto semplice ma funzionale; non viene effettuato alcun controllo al momento dell'accesso alla pagina, quindi sarebbe opportuno aggiungere il sistema di autenticazione anche a questa pagina.
Controllare i permessi
Il procedimento per controllare i permessi è molto semplice: ho modficato leggermete la pagina pagina4.php in modo che necessiti del permesso "test" (che ho precedentemente creato all'interno del database tramite la pagina di amministrazione):
<?php
include_once("include/config.php");
include_once("include/auth.lib.php");
include_once("include/utils.lib.php");
include_once("include/license.lib.php");
list($status, $user) = auth_get_status();
if($status == AUTH_LOGGED){
$msg = "Hai i seguenti permessi:<br>";
foreach(license_get($user) as $perm){
$msg .= ">> ".$perm['nome']."<br>";
}
$msg .= (license_has($user, "test"))
? "HAI IL PERMESSO TEST, e quindi ti é permesso eseguire questa operazione"
: "<b>NON</b> HAI IL PERMESSO TEST, e quindi <b>NON</b> ti é permesso eseguire questa operazione";
}else $msg = '<b><font color="red" size="5">Non hai i diritti per visualizzare la pagina</font></b>';
?>
<html>
<head>
<title>Pagina quattro</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<style type="text/css"> body,td,th { font-family: Verdana, Arial, Helvetica, sans-serif; font-size: 9px;}</style>
</head>
<body>
<?=$msg;?>
</body>
</html>
Dopo aver controllato che l'utente ha effettuato il login attraverso il metodo descritto nel primo articolo, utilizziamo la funzione license_has per controllare che l'utente abbia il permesso necessario (test): in caso affermativo visualizziamo un messaggio, in caso negativo un altro. In questo modo, utilizzando semplici istruzioni condizionali, possiamo visualizzare e permettere operazioni solamente ad utenti aventi un particolare permesso.
Potremmo per esempio visualizzare opzioni aggiuntive all'interno di un forum solamente agli utenti che hanno il permesso "moderatore", oppure visualizzare la lista dei forum in base ai permessi di visualizzazione che ha l'utente che sta visitando la pagina.
Come semplice controllo, visualizzo anche la lista di tutti i permessi associati all'utente corrente.
Siamo arrivati alla fine della mini-guida. Spero l'argomento sia stato di vostro gradimento, e vi invito ad approfondire i discorsi affrontati in modo da gestire in modo più completo i sistemi di autenticazione.
