Authentification plus facile avec la garde dans Symfony 3

Composant de garde de Symfony: rationalisation de l'authentification personnalisée

Symfony 2.8 et 3 ont introduit le composant Guard, simplifiant considérablement la création d'authentification personnalisée. Intégrant parfaitement le système de sécurité de Symfony, Guard propose une interface unifiée gérant l'intégralité de la chaîne d'authentification. Cela permet une personnalisation approfondie du processus d'authentification, englobant la soumission de formulaire, la vérification des informations d'identification et la gestion des tentatives d'authentification réussies et ratées. Son adaptabilité s'étend à divers types d'authentification, y compris la forme, les jetons, les médias sociaux et l'authentification de l'API, et prend en charge la fonctionnalité "Remember Me" et le contrôle d'accès basé sur les rôles. Surtout, la garde améliore, et non les remplace, les mécanismes de sécurité des symfony existants; Des méthodes comme form_login restent fonctionnelles.

Cet article démontre une authentification de base de base nécessitant un accès ROLE_ADMIN. Bien que l'authentification traditionnelle de la forme reste viable, l'approche rationalisée de Guard est mise en évidence. Les mêmes principes s'appliquent à d'autres méthodes d'authentification. Un exemple d'application Symfony utilisant l'authentification du garde est disponible via [ce référentiel] (link_to_repository_here - remplacer par un lien réel si disponible).

Configuration de sécurité

Une configuration de sécurité fonctionnelle nécessite une classe utilisateur (représentant des données utilisateur) et un utilisateur (récupération des données utilisateur). Pour plus de simplicité, nous utiliserons le fournisseur d'utilisateurs InMemory avec la classe d'utilisateurs par défaut de Symfony. Le fichier security.yml commence comme suit:

<code class="language-yaml">security:
    providers:
        in_memory:
            memory:
                users:
                    admin:
                        password: admin
                        roles: 'ROLE_ADMIN'</code>

(reportez-vous au site Web de Symfony pour des détails complets sur le fichier security.yml.)

Le pare-feu est défini sous la clé firewalls:

<code class="language-yaml">        secured_area:
            anonymous: ~
            logout:
                path:   /logout
                target: /
            guard:
                authenticators:
                    - form_authenticator</code>

Cela permet un accès anonyme et spécifie /logout comme chemin de déconnexion. La clé guard désigne form_authenticator (notre nom de service) comme l'authentificateur.

Les règles d'accès sont spécifiées:

<code class="language-yaml">    access_control:
            - { path: ^/login, roles: IS_AUTHENTICATED_ANONYMOUSLY }
            - { path: ^/, roles: ROLE_ADMIN }</code>

seuls les utilisateurs non authentifiés peuvent accéder à /login; Tous les autres chemins nécessitent ROLE_ADMIN.

Contrôleur de connexion

Le formulaire de connexion et le contrôleur sont définis dans le DefaultController:

<code class="language-php">  /**
   * @Route("/login", name="login")
   */
  public function loginAction(Request $request)
  {
    // ... (Existing code to handle user and authentication error) ...
  }</code>

Cette action affiche un formulaire de connexion de base (rendu par un modèle de brindille).

Guard Authenticator Service

Le service form_authenticator est défini dans services.yml:

<code class="language-yaml">services:
    form_authenticator:
          class: AppBundle\Security\FormAuthenticator
          arguments: ["@router"]</code>

La classe FormAuthenticator (détaillée ci-dessous) étend AbstractGuardAuthenticator:

<code class="language-php">namespace AppBundle\Security;

// ... (Import statements) ...

class FormAuthenticator extends AbstractGuardAuthenticator
{
    // ... (Methods: getCredentials, getUser, checkCredentials, onAuthenticationSuccess, onAuthenticationFailure, start, supportsRememberMe) ...
}</code>

Cette classe met en œuvre le pipeline d'authentification du garde:

• getCredentials(): extrait les informations d'identification des demandes de poste à /login.
• getUser(): récupère l'utilisateur en fonction du nom d'utilisateur.
• checkCredentials(): Vérifie le mot de passe contre le mot de passe stocké.
• onAuthenticationSuccess(): redirige vers la page d'accueil sur une connexion réussie.
• onAuthenticationFailure(): redirige vers la page de connexion avec les messages d'erreur.
• start(): redirige vers la page de connexion lorsque l'authentification est requise.
• supportsRememberMe(): indique si la fonctionnalité "souvenir de moi" est prise en charge.

Conclusion

Cela montre un système de connexion fonctionnel à l'aide du composant de garde. Plusieurs authentificateurs peuvent coexister, nécessitant une spécification de point d'entrée. Compléments de garde, et non remplacés, fonctionnalités de sécurité Symfony existantes.

Questions fréquemment posées (FAQ)

La section FAQ fournie propose des explications détaillées de divers aspects de l'authentification de la garde, y compris ses différences par rapport aux autres méthodes, les options de personnalisation, la gestion des rôles, le codage des mots de passe et son utilisation avec des bases de données et l'authentification sociale. Ces réponses sont complètes et traitent des préoccupations communes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!