Programmation Web côté serveur

PHP Laravel Identification et Contrôle d’accès

Fred Hémery

2018/2019
IUT Lens

Département Informatique
Principe général de la sécurité

Un mécanisme de sécurité doit garantir à chaque requête que le sujet est

autorisé à exécuter l’action sur l’objet.

Sujet Le sujet correspond à l’identité de l’utilisateur ou de

l’application obtenue après vérification des données
d’authentifications (nom de login, adresse mail, . . . associé à
un mot de passe certificat, . . . )
Action Une action provoque une modification dans le système
d’informations (lire, écrire, modifier, supprimer)
Objet Un objet est la donnée dans le système d’informations que l’on
veut sécuriser
Sécurité avec Laravel

Laravel propose un mécanisme simple de mise en oeuvre de la sécurité.

php artisan make:auth

Ajoute Les contrôleurs : RegisterController, LoginController,
ResetPasswordController et ForgotPasswordController

Utilise le modèle App\User

CREATE TABLE IF NOT EXISTS ` users ` (
`id ` INT (10) UNSIGNED NOT NULL AUTO_INCREMENT ,
` name ` VARCHAR (255) NOT NULL ,
` email ` VARCHAR (255) NOT NULL ,
` password ` VARCHAR (255) NOT NULL ,
` remember_token ` VARCHAR (100) DEFAULT NULL ,
` created_at ` TIMESTAMP NULL DEFAULT NULL ,
` updated_at ` TIMESTAMP NULL DEFAULT NULL ,
PRIMARY KEY ( ` id `) ,
UNIQUE INDEX ` users_email_unique ` ( ` email ` ASC ) )

Ajoute les vues, entre autres, login.blade.php et register.blade.php dans le

répertoire resources/views/auth associées au template dans
resources/views/layouts
Auth façade d’accès à la sécurité
La classe modèle App\User représente le sujet dans notre mécanisme de
sécurité

Les contrôleurs et les vues associées permettent de créer de nouveaux

utilisateurs et aussi gérer son mot de passe.
La classe façade Auth permet de
Vérifier qu’un utilisateur est connecté
use Illuminate \ Support \ Facades \ Auth ;

if ( Auth :: check () ) {
// The user is logged in ...
}

Récupérer les données sur l’utilisateur

use Illuminate \ Support \ Facades \ Auth ;

// Get the currently authenticated user ...

$user = Auth :: user () ;

// Get the currently authenticated user 's ID ...

$id = Auth :: id () ;
Utilisation de la façade Auth

Laravel propose un filtre (une classe middleware) qui permet de vérifier si une
route, une méthode est autorisée pour l’utilisateur identifié.
Route :: get ( ' profile ' , function () {
// Only authenticated users may enter ...
}) -> middleware ( ' auth ') ;

La protection peut se faire au niveau d’un contrôleur, dans la méthode

constructeur
public function __construct () {
$this - > middleware ( ' auth ') ;
}

La déconnexion de l’utilisateur se fait à l’aide de l’instruction suivante :

Auth :: logout () ;
Les routes par défaut

L’ajout de la ligne Auth::routes() dans le fichier web.php créer les routes

suivantes :
// Authentication Routes
$this - > get ( ' login ' , ' Auth \ L o g i n C o n t r o l l e r @ s h o w L o g i n F o r m ') ;
$this - > post ( ' login ' , ' Auth \ L o g i n C o n t r o l l e r @ l o g i n ') ;
$this - > get ( ' logout ' , ' Auth \ L o g i n C o n t r o l l e r @ l o g o u t ') ;

// Registration Routes
$this - > get ( ' register ' , ' Auth \ R e g i s t e r C o n t r o l l e r @ s h o w R e g i s t r a t i o n F o r m ') ;
$this - > post ( ' register ' , ' Auth \ R e g i s t e r C o n t r o l l e r @ r e g i s t e r ') ;

// Password Reset Routes

$this - > get ( ' password / reset ' , ' Auth \
å F o r g o t P a s s w o r d C o n t r o l l e r @ s h o w L i n k R e q u e s t F o r m ') ;
$this - > post ( ' password / email ' , ' Auth \
å F o r g o t P a s s w o r d C o n t r o l l e r @ s e n d R e s e t L i n k E m a i l ') ;
$this - > get ( ' password / reset /{ token } ' , ' Auth \
å R e s e t P a s s w o r d C o n t r o l l e r @ s h o w R e s e t F o r m ') ;
$this - > post ( ' password / reset ' , ' Auth \ R e s e t P a s s w o r d C o n t r o l l e r @ r e s e t ') ;
L’identification avec Laravel
Les éléments qui constituent l’identification avec Laravel
guard : indique le mécanisme utilisé pour gérer le contrôle à chaque requête. Par
défaut le mécanisme utilisé est la session et les cookies. Il existe d’autres
mécanismes (passport et les jetons)
provider : indique comment Laravel va récupérer les informations d’un utilisateur.
Par défaut le mécanisme utilisé est users qui stocke les données dans une base
de données.

dans le fichier config/auth.php

<? php ...
return [ ' providers ' = > [
' defaults ' = > [ ' users ' = > [
' guard ' = > ' web ' , ' driver ' = > ' eloquent ' ,
' passwords ' = > ' users ' , ' model ' = > App \ User :: class ,
], ],
' guards ' = > [ ],
' web ' = > [ ' passwords ' = > [
' driver ' = > ' session ' , ' users ' = > [
' provider ' = > ' users ' , ' provider ' = > ' users ' ,
], ' table ' = > '
' api ' = > [ åpassword_resets ' ,
' driver ' = > ' token ' , ' expire ' = > 60 ,
' provider ' = > ' users ' , ],
], ],
], ];
...
Le contrôle d’accès peut se faire selon deux approches :

Gate qui utilise une approche simplifiée, en général, sans être

attaché à un modèle particulier mais plutôt à une vue
particulière ;
Policy qui est relié à un modèle
Gate

On définit une Gate dans le fichier App\Providers\AuthServiceProvider

public function boot () {
$this - > registerPolicies () ;

Gate :: define ( ' update - post ' , function ( $user , $post ) {

return $user - > id == $post - > user_id ;
}) ;
}

ou encore à l’aide de l’écriture Classe@fonction

public function boot ()
{
$this - > registerPolicies () ;

Gate :: define ( ' update - post ' , ' Po stP oli cy@ upd ate ') ;
}
Gate Ressource

Il est possible de définir en une fois les 4 méthodes de base CRUD

public function boot ()
{
$this - > registerPolicies () ;

Gate :: resource ( ' posts ' , ' PostPolicy ') ;

}

Ce qui le même effet que

public function boot ()
{
$this - > registerPolicies () ;

Gate :: define ( ' posts . view ' , ' PostPolicy@view ') ;

Gate :: define ( ' posts . create ' , ' Po stP oli cy@ cr eat e ') ;
Gate :: define ( ' posts . update ' , ' Po stP oli cy@ up dat e ') ;
Gate :: define ( ' posts . delete ' , ' Po stP oli cy@ de let e ') ;
}
Gate Utilisation

Pour gérer l’accès à l’aide d’une Gate on utilise les méthodes allows, denies.
Dans l’exemple, l’utilisateur testé est celui qui est connecté.
if ( Gate :: allows ( ' update - post ' , $post ) ) {
// The current user can update the post ...
}

if ( Gate :: denies ( ' update - post ' , $post ) ) {

// The current user can 't update the post ...
}

Si on veut tester pour un utilisateur en particulier, on utilise la méthode forUser.

if ( Gate :: forUser ( $user ) -> allows ( ' update - post ' , $post ) ) {
// The user can update the post ...
}

if ( Gate :: forUser ( $user ) -> denies ( ' update - post ' , $post ) ) {
// The user can 't update the post ...
}
Policy

Une Policy est une classe qui est associée à un modèle par exemple le modèle
Post est associé avec la politique d’accès définie dans la classe dans le fichier
PostPolicy

Laravel propose une commande pour générer une classe de politique d’accès
pour un modèle
php artisan make : policy PostPolicy

ou pour les méthodes CRUD

php artisan make : policy PostPolicy -- model = Post
Policy Enregistrement

Une fois créée, la politique d’accès doit être enregistrée dans le fichier
App\Providers\AuthServiceProvider
<? php

use App \ Post ;

use App \ Policies \ PostPolicy ;
use Illuminate \ Support \ Facades \ Gate ;
use Illuminate \ Foundation \ Support \ Providers \ A u t h S e r v i c eP r o v i d e r as
åServiceProvider ;

class A u t h S e r vi c e P r o v i d e r extends ServiceProvider {

protected $policies = [
Post :: class = > PostPolicy :: class ,
];

public function boot () {

$this - > registerPolicies () ;
}
}
Policy Implémentation
Avec la classe PostPolicy et la méthode update qui utilise deux paramètres :
L’utilisateur ($user) qui souhaite effectuer l’action, et
l’objet ($post) qui va être modifié
<? php

namespace App \ Policies ;

use App \ User ;

use App \ Post ;

class PostPolicy {

public function update ( User $user , Post $post ) {

return $user - > id === $post - > user_id ;
}
}

La méthode renvoie true si l’action est autorisée et false sinon.

Si la méthode n’a pas besoin d’une instance de modèle, on utilise qu’un seul
paramètre
public function create ( User $user )
{
//
}
Policy Utilisation
En utilisant l’utilisateur connecté sur une instance d’un modèle
if ( $user - > can ( ' update ' , $post ) ) { // }

On vérifie que l’utilisateur à le droit d’effectuer l’action ’update’ sur l’objet $post.

En utilisant l’utilisateur connecté sans instance de modèle

if ( $user - > can ( ' create ' , Post :: class ) ) { // }

en utilisant un filtre
use App \ Post ;

Route :: put ( '/ post /{ post } ' , function ( Post $post ) {

// The current user may update the post ...
}) -> middleware ( ' can : update , post ') ;

Route :: post ( '/ post ' , function () {

// The current user may create posts ...
}) -> middleware ( ' can : create , App \ Post ') ;

Le filtre can vérifie que l’utilisateur connecté a le droit d’exécuter l’action update
sur l’objet post qui correspond au paramètre ({post}) de la règle de routage. La
méthode create utilise le nom de la classe comme 2ème paramètre.
Policy Utilisation (suite)
Dans un contrôleur qui hérite de la classe App\Http\Controllers\Controller,
il est possible d’utiliser la méthode authorize
<? php
namespace App \ Http \ Controllers ;

use App \ Post ;

use Illuminate \ Http \ Request ;
use App \ Http \ Controllers \ Controller ;

class PostController extends Controller

{
public function update ( Request $request , Post $post ) {
$this - > authorize ( ' update ' , $post ) ;
// The current user can update the blog post ...
}
public function create ( Request $request ) {
$this - > authorize ( ' create ' , Post :: class ) ;
// The current user can create blog posts ...
}
}

En cas d’echec la méthode authorize génère une exception

Illuminate\Auth\Access\AuthorizationException (renvoie une page avec le
code HTTP 403)
Policy Utilisation (suite)
Des directives sont disponibles dans le préprocesseur de templates blade.

@can ( ' update ' , $post ) equivalent de

<! - - The Current User Can Update
åThe Post --> @if ( Auth :: user () -> can ( ' update ' , $post
@elsecan ( ' create ' , $post ) å) )
<! - - The Current User Can Create <! - - The Current User Can Update
åNew Post --> åThe Post -->
@endcan @endif

@cannot ( ' update ' , $post ) @unless ( Auth :: user () -> can ( ' update ' ,
<! - - The Current User Can ` t Update å$post ) )
å The Post --> <! - - The Current User Can ` t Update
@elsecannot ( ' create ' , $post ) å The Post -->
<! - - The Current User Can ` t Create @endunless
å New Post -->
@endcannot

Si la méthode n’a pas besoin d’instance d’un modèle

@can ( ' create ' , App \ Post :: class )
<! - - The Current User Can Create Posts -->
@endcan

@cannot ( ' create ' , App \ Post :: class )

<! - - The Current User Can ` t Create Posts -->
@endcannot