Authentification¶

Hashage du mot de passe¶

Le hashage automatique de votre champ mot de passe se produit seulement si les données postées contiennent à la fois les champs “username” et “password”.

Quand vous postez des informations à une action via un formulaire, le composant Auth hashe (crypte) automatiquement le contenu de votre champ mot de passe, si les données postées contiennent aussi le champ “username”. Donc, si vous essayez de créer une page d’inscription quelconque, assurez-vous que l’utilisateur ait rempli un champ “confirmation du mot de passe” pour comparer les deux. Voici un exemple de code :

<?php
function enregistrer() {
    if ($this->data) {
        if ($this->data['User']['password'] == $this->Auth->password($this->data['User']['password_confirm'])) {
            $this->User->create();
            $this->User->save($this->data);
        }
    }
}
?>

action¶

action (string $action = ':controller/:action')

Si vous utilisez les ACOs dans le cadre de votre structure ACL, vous pouvez obtenir le chemin jusqu’au nœud ACO relié à un couple contrôleur/action particulier :

$acoNode = $this->Auth->action('users/delete');

Si vous ne passez pas de valeur, le couple contrôleur/action courant est utilisé.

allow¶

Si vous avez des actions dans votre contrôleur que vous n’avez pas besoin d’authentifier (comme une action d’enregistrement d’un utilisateur), vous pouvez ajouter des méthodes que le composant Auth devrait ignorer. L’exemple suivant montre comment autoriser une action intitulée “enregistrer”.

function beforeFilter() {
    ...
    $this->Auth->allow('enregistrer');
}

Si vous souhaitez autoriser plusieurs actions qui échapperont à l’authentification, passez-les en paramètres à la méthode allow() :

function beforeFilter() {
    ...
    $this->Auth->allow('foo', 'bar', 'baz');
}

Raccourci : vous pouvez aussi autoriser toutes les actions d’un contrôleur en utilisant “*”.

function beforeFilter() {
    ...
    $this->Auth->allow('*');
}

Si vous utilisez requestAction dans votre layout ou vos éléments, vous devriez autoriser ces actions de façon à être capable d’ouvrir la page de login proprement.

Le composant Auth suppose que les noms de vos actions respectent les conventions et qu’elles sont « underscorées ».

deny¶

Il peut arriver que vous vouliez retirer des actions de la liste des actions autorisées (déclarée en utilisant $this->Auth->allow()). Voici un exemple :

function beforeFilter() {
    $this->Auth->authorize = 'controller';
    $this->Auth->allow('delete');
}

function isAuthorized() {
    if ($this->Auth->user('role') != 'admin') {
        $this->Auth->deny('delete');
    }

    ...
}

hashPasswords¶

hashPasswords ($data)

Cette méthode vérifie si $data contient les champs username et password, comme spécifié par la variable $fields, elle même indexée par le nom du modèle, comme spécifié dans $userModel. Si le tableau $data contient à la fois username et password, la méthode encode le champ password du tableau et retourne le tableau $data dans le même format. Cette fonction devrait être utilisée en priorité pour les requêtes d’insertion ou de mise à jour de l’utilisateur, quand le champ password est affecté.

$data['User']['username'] = '[email protected]';
$data['User']['password'] = 'changemoi';
$hashedPasswords = $this->Auth->hashPasswords($data);
print_r($hashedPasswords);
/* retourne :
Array
(
    [User] => Array
    (
        [username] => [email protected]
        [password] => 8ed3b7e8ced419a679a7df93eff22fae
    )
)

*/

Le champ $hashedPasswords[“User”][“password”] sera maintenant encodé en utilisant la fonction password du composant.

Si votre contrôleur utilise le composant Auth et que les données postées contiennent les champs mentionnés ci-dessus, il encodera automatiquement le mot de passe en utilisant cette fonction.

mapActions¶

Si vous utilisez les Acl en mode CRUD, vous aimeriez peut-être assigner certaines actions non-standards à chaque partie du CRUD.

$this->Auth->mapActions(
    array(
        'create' => array('uneAction'),
        'read' => array('uneAction', 'uneAction2'),
        'update' => array('uneAction'),
        'delete' => array('uneAction')
    )
);

login¶

login($data = null)

Si vous souhaitez une authentification depuis un composant Ajax, vous pouvez utiliser cette méthode pour authentifier manuellement un utilisateur dans le système. Si vous ne passez aucune valeur pour $data, les données reçues en POST seront alors automatiquement passées au controlleur.

logout¶

Cette méthode fournit une manière rapide de désauthentifier quelqu’un et de le rediriger là où il a besoin d’aller.

Cette méthode est également pratique si vous voulez proposer un lien “Déconnexion” dans la partie membres de votre application.

Exemple :

$this->redirect($this->Auth->logout());

password¶

password (string $password)

Passez une chaîne à cette méthode et vous pourrez voir à quoi ressemblera le mot de passe crypté. C’est une fonctionnalité essentielle si vous créez un écran d’inscription où les utilisateurs doivent entrer deux fois leur mot de passe pour le confirmer.

if ($this->data['User']['password'] ==
    $this->Auth->password($this->data['User']['password2'])) {

    // Les mots de passe correspondent, on continue
    ...
} else {
    $this->flash('Les mots de passe saisis ne correspondent pas', 'users/register');
}

Le composant Auth encryptera automatiquement le champ password si le champ username est aussi présent dans les données envoyées.

Cake ajoute un « grain de sécurité » (Security.salt) à votre chaîne de mot de passe et crypte le tout ensuite. La fonction de cryptage utilisée dépend de celle définie dans la classe utilitaire Security de CakePHP (sha1 par défaut). Vous pouvez utiliser la fonction Security::setHash pour changer la méthode de cryptage. Le « grain de sécurité » est configuré dans le fichier core.php de votre application.

user¶

user(string $key = null)

Cette méthode fournit des informations sur l’utilisateur connecté. Ces informations sont issues de la session. Par exemple :

if ($this->Auth->user('role') == 'admin') {
    $this->flash('Vous avez un accès administrateur');
}

Elle peut aussi être utilisée pour obtenir des informations complètes sur la session de l’utilisateur, de cette façon :

$data['User'] = $this->Auth->user();

Si cette méthode renvoie null, l’utilisateur n’est pas connecté.

Dans les vues, vous pouvez utiliser l’assistant Session, pour retrouver les informations sur l’utilisateur actuellement connecté :

$session->read('Auth.User'); // renvoie l'ensemble des informations sur l'utilisateur
$session->read('Auth.User.first_name') // renvoie la valeur d'un champ en particulier

La clé de session peut être différente en fonction du modèle configuré pour utiliser Auth. Par exemple, si vous utilisez le modèle Compte au lieu de User, alors la clé de session sera Auth.Compte.

userModel¶

Vous ne voulez pas utiliser un modèle Utilisateur pour vous authentifier ? Pas de problème, modifiez ce comportement en configurant cette variable avec le nom du modèle que vous voulez utiliser.

<?php
    $this->Auth->userModel = 'Membre';
?>

fields¶

Pour outrepasser les champs utilisateur et mot de passe utilisés par défaut pour l’authentification.

<?php
    $this->Auth->fields = array('username' => 'email', 'password' => 'motdepasse');
?>

userScope¶

Utilisez cette propriété pour ajouter des contraintes supplémentaires afin que l’authentification réussisse.

<?php
    $this->Auth->userScope = array('Utilisateur.actif' => true);
?>

loginAction¶

Vous pouvez changer l’adresse de connexion par défaut /users/login par toute action de votre choix.

<?php
    $this->Auth->loginAction = array('admin' => false, 'controller' => 'membres', 'action' => 'login');
?>

loginRedirect¶

Le Composant Auth mémorise quelle paire contrôleur/action vous essayiez d’obtenir avant que l’on vous demande de vous authentifier, en stockant cette valeur dans la Session, sous la clé Auth.redirect. Cependant, si cette valeur de session n’est pas définie (par exemple, si vous arrivez à la page d’identification depuis un lien externe), alors l’utilisateur sera redirigé à l’URL spécifiée dans loginRedirect.

Exemple :

<?php
    $this->Auth->loginRedirect = array('controller' => 'membres', 'action' => 'accueil');
?>

logoutRedirect¶

Vous pouvez également spécifier où vous voulez que l’utilisateur soit redirigé après sa déconnexion, ayant pour action par défaut l’action de login.

<?php
    $this->Auth->logoutRedirect = array(Configure::read('Routing.admin') => false, 'controller' => 'membres', 'action' => 'logout');
?>

loginError¶

Change le message d’erreur par défaut affiché lorsque quelqu’un ne s’authentifie pas correctement.

<?php
    $this->Auth->loginError = "Non, vous vous êtes trompé! Ce n'est pas le bon mot de passe!";
?>

authError¶

Change le message d’erreur par défaut affiché lorsque quelqu’un essaye d’accéder à une ressource ou une action qu’il n’est pas autorisé à accéder.

<?php
    $this->Auth->authError = "Désolé, vous n'avez pas les droits suffisants.";
?>

autoRedirect¶

Normalement, le Composant Auth vous redirige automatiquement dès lors qu’il vous authentifie. Parfois, vous souhaitez faire d’autres vérifications avant de rediriger les utilisateurs :

<?php
    function beforeFilter() {
        ...
        $this->Auth->autoRedirect = false;
    }

    ...

    function login() {
    //-- le code de cette fonction ne s'exécute que lorsque autoRedirect est défini à false (i.e. dans un beforeFilter).
        if ($this->Auth->user()) {
            if (!empty($this->data['Utilisateur']['se_souvenir_de_moi'])) {
                $cookie = array();
                $cookie['nom'] = $this->data['Utilisateur']['nom'];
                $cookie['motdepasse'] = $this->data['Utilisateur']['motdepasse'];
                $this->Cookie->write('Auth.Utilisateur', $cookie, true, '+2 weeks');
                unset($this->data['Utilisateur']['se_souvenir_de_moi']);
            }
            $this->redirect($this->Auth->redirect());
        }
        if (empty($this->data)) {
            $cookie = $this->Cookie->read('Auth.Utilisateur');
            if (!is_null($cookie)) {
                if ($this->Auth->login($cookie)) {
                    //  Efface le message auth, seulement si nous l'utilisons
                    $this->Session->delete('Message.auth');
                    $this->redirect($this->Auth->redirect());
                }
            }
        }
    }
?>

Le code de la fonction login ne s’exécutera pas sauf si vous définissez $autoRedirect à false dans un beforeFilter. Le code présent dans la fonction de login ne s’exécutera qu’après un essai d’authentification. C’est le meilleur endroit pour déterminer si oui ou non une connexion réussie a été effectuée par le Composant Auth (vous aurez peut-être envie d’enregistrer la dernière date d’authentification réussie, etc.).

authorize¶

Normalement, le Composant Auth essaiera de vérifier que les critères de login que vous avez saisis sont exacts, en les comparant à ce qui a été stocké dans votre modèle utilisateur. Cependant, vous voudrez peut-être certaines fois effectuer du traitement additionnel, en déterminant vos propres critères. En assignant à cette variable l’une des nombreuses valeurs possibles, vous pouvez faire différentes choses. En voici quelques-unes, parmi les plus communes, que vous souhaiterez peut-être utiliser.

<?php
    $this->Auth->authorize = 'controller';
?>

Lorsque authorize est défini à “controller”, vous aurez besoin d’ajouter une méthode appelée isAuthorized() à votre contrôleur. Cette méthode vous permet de faire plus de vérifications d’authentification et de retourner ensuite soit true, soit false.

<?php
    function isAuthorized() {
        if ($this->action == 'delete') {
            if ($this->Auth->user('role') == 'admin') {
                return true;
            } else {
                return false;
            }
        }

        return true;
    }
?>

Souvenez-vous que cette méthode sera inspectée, après que vous ayez déjà passé la vérification d’authentification simple du modèle utilisateur.

<?php
    $this->Auth->authorize = 'model';
?>

Vous ne souhaitez rien ajouter à votre contrôleur et peut-être utiliser les ACO’s ? Vous pouvez demander au Composant Auth d’appeler une méthode, nommée isAuthorized(), dans votre modèle utilisateur, pour faire le même genre de choses :

<?php
    class Utilisateur extends AppModel {
        ...

        function isAuthorized($utilisateur, $controleur, $action) {

            switch ($action) {
                case 'default':
                    return false;
                    break;
                case 'delete':
                    if ($utilisateur['Utilisateur']['role'] == 'admin') {
                        return true;
                    }
                    break;
            }
        }
    }
?>

Enfin, vous pouvez utiliser authorize avec les actions, comme montré ci-dessous :

<?php
    $this->Auth->authorize = 'actions';
?>

En utilisant actions, Auth utilisera l’ACL et vérifiera avec AclComponent::check(). Une fonction isAuthorized n’est pas nésessaire.

<?php
    $this->Auth->authorize = 'crud';
?>

En utilisant crud, Auth utilisera l’ACL et vérifiera avec AclComponent::check(). Les actions devraient correspondre aux CRUD (voir mapActions).

sessionKey¶

Nom de la clé du tableau de session où l’enregistrement de l’utilisateur actuellement authentifié est stocké.

Par défaut, vaut « Auth », donc si non spécifié, l’enregistrement est stocké dans « Auth.{nom $modeleUtilisateur} ».

<?php
    $this->Auth->sessionKey = 'Autorise';
?>

ajaxLogin¶

Si vous faites des requêtes Ajax ou Javascript qui nécessitent des sessions authentifiées, donnez à cette variable le nom d’un élément de vue que vous souhaiteriez rendre et retourner quand vous avez une session invalide ou expirée.

Comme dans toute partie de CakePHP, soyez certains d’avoir jeté une œil à la classe AuthComponent dans l’API, pour avoir une vision plus approfondie du composant Auth.

authenticate¶

Cette variable contient une référence à l’objet responsable du hashage des mots de passe, s’il est nécessaire de changer/surcharger le mécanisme de hashage des mots de passe par défaut. Voyez Changer le type de cryptage pour plus d’info.

actionPath¶

Si vous utilisez le contrôle d’accès basé sur les actions, ceci définit la façon dont sont déterminés les chemins vers les nœuds ACO de l’action. Si, par exemple, tous les nœuds de contrôleur sont imbriqués sous un nœud ACO nommé “Controllers”, $actionPath devrait être défini à “Controllers/”.

5.2.6.15 flashElement¶

Si vous voulez utiliser un autre layout pour votre message d’erreur d’Authentification, vous pouvez le définir avec la variable flashElement. Cet autre élément sera utilisé pour l’affichage.

<?php
    $this->Auth->flashElement    = "message_erreur";
?>