Symfony2 - Jobeet - Jour 13 - Sécurité

1 1 1 1 1 1 1 1 1 1 Rating 0.00 (0 Votes)
Submit to DeliciousSubmit to DiggSubmit to FacebookSubmit to Google PlusSubmit to StumbleuponSubmit to TechnoratiSubmit to TwitterSubmit to LinkedIn

Sécurisation de l'application

La sécurité est un processus en deux étapes dont le but est d'empêcher un utilisateur d'accéder à une ressource dont il ne devrait pas avoir accès. Dans la première étape du processus, l'authentification, le système de sécurité identifie l'utilisateur en l'obligeant à soumettre une sorte d'identification. Une fois que le système sait qui vous êtes, la prochaine étape, appelée l'autorisation, est de déterminer si vous devriez avoir accès à une ressource donnée (il vérifie que vous avez les privilèges pour effectuer une certaine action).

Le composant de sécurité peut être configuré via la configuration de votre application à l'aide du fichier security.yml à partir du dossier app/config. Pour sécuriser notre application ajoutez ce qui suit à votre fichier security.yml :

  • app/config/security.yml
security:
    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]

    firewalls:
        dev:
            pattern:  ^/(_(profiler|wdt)|css|images|js)/
            security: false

        secured_area:
            pattern:    ^/
            anonymous: ~
            form_login:
                login_path:  /login
                check_path:  /login_check
                default_target_path: erlem_jobeet_homepage

    access_control:
        - { path: ^/admin, roles: ROLE_ADMIN }

    providers:
        in_memory:
            memory:
                users:
                    admin: { password: adminpass, roles: 'ROLE_ADMIN' }

    encoders:
        Symfony\Component\Security\Core\User\User: plaintext

Cette configuration protégera la section /admin du site (toutes les URL qui commencent par /admin) et permettra l'accès uniquement aux utilisateurs avec ROLE_ADMIN (voir la section access_control). Dans cet exemple, l'utilisateur admin est défini dans le fichier de configuration (la section providers) et le mot de passe n'est pas chiffré (encoders).

Pour authentifier les utilisateurs, un formulaire de connexion classique sera utilisé, mais nous devons le mettre en œuvre. D'abord, créez deux routes : l'une qui affiche le formulaire de connexion (par exemple /login) et une qui va gérer la soumission du formulaire de connexion (par exemple /login_check) :

  • src/Erlem/JobeetBundle/Resources/config/routing.yml
login:
    pattern:   /login
    defaults:  { _controller: ErlemJobeetBundle:Default:login }
login_check:
    pattern:   /login_check

# ...

Nous n'aurons pas besoin de mettre en œuvre un contrôleur pour l'URL /login_check puisque le pare-feu va automatiquement intercepter et transformer n'importe quel formulaire soumis à cette URL. Il est facultatif, mais utile, pour créer une route de sorte qu'il peut être utilisé pour générer l'URL de soumission du formulaire dans le template de connexion ci-dessous.

Ensuite, nous allons créer l'action qui permettra d'afficher le formulaire de connexion :

  • src/Erlem/JobeetBundle/Controller/DefaultController.php
namespace Erlem\JobeetBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Security\Core\SecurityContext;

class DefaultController extends Controller
{
    // ...

    public function loginAction()
    {
        $request = $this->getRequest();
        $session = $request->getSession();

        // get the login error if there is one
        if ($request->attributes->has(SecurityContext::AUTHENTICATION_ERROR)) {
            $error = $request->attributes->get(SecurityContext::AUTHENTICATION_ERROR);
        } else {
            $error = $session->get(SecurityContext::AUTHENTICATION_ERROR);
            $session->remove(SecurityContext::AUTHENTICATION_ERROR);
        }

        return $this->render('ErlemJobeetBundle:Default:login.html.twig', array(
            // last username entered by the user
            'last_username' => $session->get(SecurityContext::LAST_USERNAME),
            'error'         => $error,
        ));
    }
}

Lorsque l'utilisateur soumet le formulaire, le système de sécurité gère automatiquement la soumission du formulaire pour vous. Si l'utilisateur a soumis un nom d'utilisateur ou mot de passe invalide, cette action lit l'erreur de soumission du formulaire à partir du système de sécurité de sorte qu'il peut être affiché à l'utilisateur. Votre seule tâche est d'afficher le formulaire de connexion et les erreurs de connexion qui peuvent se produire, mais le système de sécurité lui-même prend soin de vérifier le nom d'utilisateur et mot de passe soumis et l'authentification de l'utilisateur.

Enfin, nous allons créer le template correspondant :

  • src/Erlem/JobeetBundle/Resources/views/Default/login.html.twig
{% if error %}
    <div>{{ error.message }}</div>
{% endif %}

<form action={{ path('login_check') }} method="post">
    <label for="username">Username:</label>
    <input type="text" id="username" name="_username" value='{{ last_username }}' />

    <label for="password">Password:</label>
    <input type="password" id="password" name="_password" />

    <button type="submit">login</button>
</form>

Maintenant, si vous essayez d'accéder à l'URL http://jobeet.local/app_dev.php/admin/dashboard, le formulaire de connexion apparaîtra et vous devrez entrer le nom d'utilisateur et mot de passe défini dans security.yml (admin/adminpass) pour aller dans l'administration de Jobeet.

Les fournisseurs d'utilisateurs

Lors de l'authentification, l'utilisateur soumet un ensemble d'informations d'identification (généralement un nom d'utilisateur et mot de passe). La tâche du système d'authentification est de faire correspondre ces informations à certains groupes d'utilisateurs. Alors d'où vient cette liste d'utilisateurs ?

Dans Symfony2, les utilisateurs peuvent venir de n'importe où - un fichier de configuration, une table de la BDD, un Web Service, ou toute autre chose dont vous pouvez rêver. Tout ce qui fournit un ou plusieurs utilisateurs dans le système d'authentification est connu comme un "fournisseur d'utilisateur". Symfony2 est livré en standard avec les deux fournisseurs d'utilisateurs les plus courants : celui qui charge les utilisateurs à partir d'un fichier de configuration et celui qui charge les utilisateurs d'une table de la BDD.

Ci-dessus, nous avons utilisé le premier cas : les utilisateurs spécifiés dans un fichier de configuration.

  • app/config/security.yml
# ...

providers:
    in_memory:
        memory:
            users:
                admin: { password: adminpass, roles: 'ROLE_ADMIN' }

# ...

Mais vous voudrez généralement stocker les utilisateurs dans une table de la BDD. Pour ce faire, nous allons ajouter une nouvelle table user dans notre BDD.

D'abord nous allons créer l'ORM pour cette nouvelle table :

  • src/Erlem/JobeetBundle/Resources/config/doctrine/User.orm.yml
Erlem\JobeetBundle\Entity\User:
    type: entity
    table: user
    id:
        id:
            type: integer
            generator: { strategy: AUTO }
    fields:
        username:
            type: string
            length: 255
        password:
            type: string
            length: 255

Maintenant, exécutez la commande doctrine:generate:entities pour créer la nouvelle entité User :

php app/console doctrine:generate:entities ErlemJobeetBundle

Et mettez à jour la BDD :

php app/console doctrine:schema:update --force

La seule exigence pour votre nouvelle classe User est qu'elle implémente l'interface UserInterface. Cela signifie que votre concept d'un "utilisateur" peut être n'importe quoi, tant qu'il implémente cette interface. Ouvrez le fichier User.php et modifiez-le comme suit :

  • src/Erlem/JobeetBundle/Entity/User.php
namespace Erlem\JobeetBundle\Entity;

use Symfony\Component\Security\Core\User\UserInterface;
use Doctrine\ORM\Mapping as ORM;

/**
 * User
 */
class User implements UserInterface
{
    /**
     * @var integer
     */
    private $id;

    /**
     * @var string
     */
    private $username;

    /**
     * @var string
     */
    private $password;

    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set username
     *
     * @param string $username
     * @return User
     */
    public function setUsername($username)
    {
        $this->username = $username;

    }

    /**
     * Get username
     *
     * @return string 
     */
    public function getUsername()
    {
        return $this->username;
    }

    /**
     * Set password
     *
     * @param string $password
     * @return User
     */
    public function setPassword($password)
    {
        $this->password = $password;

    }

    /**
     * Get password
     *
     * @return string 
     */
    public function getPassword()
    {
        return $this->password;
    }

    public function getRoles()
    {
        return array('ROLE_ADMIN');
    }

    public function getSalt()
    {
        return null;
    }

    public function eraseCredentials()
    {

    }

    public function equals(User $user)
    {
        return $user->getUsername() == $this->getUsername();
    }        
}

Pour l'entité générée, nous avons ajouté les méthodes requises par la classe UserInterface: GetRoles, getSalt, eraseCredentials et equals.

Ensuite, configurez un fournisseur d'entité utilisateur, et faites-le pointer vers votre classe User :

  • app/config/security.yml
...

    providers:
        main:
            entity: { class: Erlem\JobeetBundle\Entity\User, property: username }

    encoders:
        Erlem\JobeetBundle\Entity\User: sha512

Nous avons également changé le chiffrage pour notre nouvelle classe User afin d'utiliser l'algorithme sha512 pour hasher les mots de passe.

Maintenant, tout est mis en place, mais nous avons besoin de créer notre premier utilisateur. Pour ce faire, nous allons créer une nouvelle commande de Symfony :

  • src/Erlem/JobeetBundle/Command/JobeetUsersCommand.php
<?php

namespace Erlem\JobeetBundle\Command;

use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Erlem\JobeetBundle\Entity\User;

class JobeetUsersCommand extends ContainerAwareCommand
{
    protected function configure()
    {
        $this
            ->setName('erlem:jobeet:users')
            ->setDescription('Add Jobeet users')
            ->addArgument('username', InputArgument::REQUIRED, 'The username')
            ->addArgument('password', InputArgument::REQUIRED, 'The password')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $username = $input->getArgument('username');
        $password = $input->getArgument('password');

        $em = $this->getContainer()->get('doctrine')->getManager();

        $user = new User();
        $user->setUsername($username);
        // encode the password
        $factory = $this->getContainer()->get('security.encoder_factory');
        $encoder = $factory->getEncoder($user);
        $encodedPassword = $encoder->encodePassword($password, $user->getSalt());
        $user->setPassword($encodedPassword);
        $em->persist($user);
        $em->flush();

        $output->writeln(sprintf('Added %s user with password %s', $username, $password));
    }
}

Pour ajouter votre premier utilisateur exécutez :

php app/console erlem:jobeet:users admin admin

Cela va créer l'utilisateur admin avec le mot de passe admin. Vous pouvez l'utiliser pour vous connecter à l'admininistration.

Déconnexion

La déconnexion est gérée automatiquement par le pare-feu. Tout ce que vous avez à faire est d'activer le paramètre logout :

  • app/config/security.yml
security:
    firewalls:
        # ...
        secured_area:
            # ...
            logout:
                path:   /logout
                target: /
    # ...

Une fois que cela est configuré dans votre pare-feu, l'envoi d'un utilisateur vers /logout (ou le paramètre path que vous avez configuré), déconnectera l'utilisateur en cours. L'utilisateur sera alors envoyé à la page d'accueil (la valeur définie par le paramètre target).

Vous n'aurez pas besoin de mettre en œuvre un contrôleur pour l'URL /logout puisque le pare-feu s'occupe de tout. Vous pouvez, cependant, vouloir créer une route de sorte que vous pouvez l'utiliser pour générer l'URL :

  • src/Erlem/JobeetBundle/Resources/config/routing.yml
# ...

logout:
    pattern:   /logout

# ...

Tout ce qui reste à faire est d'ajouter le lien de déconnexion à notre administration. Pour ce faire, nous allons remplacer le user_block.html.twig de SonataAdminBundle. Créez le fichier user_block.html.twig dans le répertoire app/Resources/SonataAdminBundle/views/Core/ :

  • app/Resources/SonataAdminBundle/views/Core/user_block.html.twig
{% block user_block %}<a href={{ path('logout') }}>Logout</a>{% endblock%}

Maintenant, si vous essayez d'entrer dans l'administration, il vous sera demandé un nom d'utilisateur et un mot de passe, puis, le lien de déconnexion sera affiché dans le coin supérieur droit.

Pour vous déconnecter :

Pour se connecter :

Pour accèder directement à l'administration :

01-112-symfony2-jobeet-jour-13-securite

La session utilisateur

Symfony2 fournit un objet de session que vous pouvez utiliser pour stocker des informations sur l'utilisateur entre les requêtes. Par défaut, Symfony2 stocke les attributs dans un cookie par l'intermédiaire des sessions PHP natives.

Vous pouvez stocker et récupérer des informations à partir de la session facilement depuis le contrôleur :

$session = $this->getRequest()->getSession();
 
// store an attribute for reuse during a later user request
$session->set('foo', 'bar');
 
// in another controller for another request
$foo = $session->get('foo');

Malheureusement, les scénarios de Jobeet n'ont aucune exigence qui comprend le stockage d'informations dans la session utilisateur. Nous allons donc ajouter une nouvelle exigence : pour faciliter la navigation dans l'offre, les trois dernières offres vues par l'utilisateur doivent être affichées dans le menu avec des liens pour revenir à la page des offres par la suite.

Lorsqu'un utilisateur accède à la page d'une offre, l'objet de l'offre affichée doit être ajouté dans l'historique de l'utilisateur et stocké dans la session :

  • src/Erlem/JobeetBundle/Controller/JobController.php
// ...

public function showAction($id)
{
    $em = $this->getDoctrine()->getManager();

    $entity = $em->getRepository('ErlemJobeetBundle:Job')->getActiveJob($id);

    if (!$entity) {
        throw $this->createNotFoundException('Unable to find Job entity.');
    }

    $session = $this->getRequest()->getSession();

    // fetch jobs already stored in the job history
    $jobs = $session->get('job_history', array());

    // store the job as an array so we can put it in the session and avoid entity serialize errors
    $job = array('id' => $entity->getId(), 'position' =>$entity->getPosition(), 'company' => $entity->getCompany(), 'companyslug' => $entity->getCompanySlug(), 'locationslug' => $entity->getLocationSlug(), 'positionslug' => $entity->getPositionSlug());

    if (!in_array($job, $jobs)) {
        // add the current job at the beginning of the array
        array_unshift($jobs, $job);

        // store the new job history back into the session
        $session->set('job_history', array_slice($jobs, 0, 3));
    }

    $deleteForm = $this->createDeleteForm($id);

    return $this->render('ErlemJobeetBundle:Job:show.html.twig', array(
        'entity'      => $entity,
        'delete_form' => $deleteForm->createView(),
    ));
}

Dans le layout, ajoutez le code suivant avant la div #content :

  • src/Erlem/JobeetBundle/Resources/views/layout.html.twig
<!-- ... -->

<div id="job_history">
    Recent viewed jobs:
    <ul>
        {% for job in app.session.get('job_history') %}
            <li>
                <a href={{ path('erlem_job_show', { 'id': job.id, 'company': job.companyslug, 'location': job.locationslug, 'position': job.positionslug }) }}>{{ job.position }} - {{ job.company }}</a>
            </li>
        {% endfor %}
    </ul>
</div>

<div id="content">

<!-- ... -->

02-112-symfony2-jobeet-jour-13-securite

Les messages flash

Les messages flash sont des petits messages que vous pouvez stocker sur la session de l'utilisateur pendant exactement une requête supplémentaire. Cette fonction est utile lors du traitement d'un formulaire : vous souhaitez rediriger et afficher un message spécial sur la requête suivante. Nous avons déjà utilisé des messages flash dans notre projet lorsque nous publions une offre :

  • src/Erlem/JobeetBundle/Controller/JobController.php
// ...

public function publishAction($token)
{
    // ...

    $this->get('session')->getFlashBag()->add('notice', 'Your job is now online for 30 days.');

    // ...
}

Le premier argument de la fonction setFlash est l'identifiant du flash et le second est le message à afficher. Vous pouvez définir les flashs que vous voulez, mais notice et error sont les deux plus communs.

Pour afficher les messages flash à l'utilisateur, vous devez les inclure dans le template. Nous l'avons fait dans le template layout.html.twig :

  • src/Erlem/JobeetBundle/Resources/views/layout.html.twig
<!-- ... -->

{% for flashMessage in app.session.flashbag.get('notice') %}
    <div>
        {{ flassMessage }}
    </div>
{% endfor %}

<!-- ... -->

Symfony2 - Jour 12 - Le paquet Admin
[Sommaire] Symfony2 - Jour 14 - Flux de données >


Pour ce tutoriel, je me suis inspiré du tutoriel Symfony2 Jobeet du site IntelligentBee

Submit to DeliciousSubmit to DiggSubmit to FacebookSubmit to Google PlusSubmit to StumbleuponSubmit to TechnoratiSubmit to TwitterSubmit to LinkedIn