Sécurité

B) Configurez "comment charger les utilisateurs" ¶

Lorsque vous entrez le nom d'utilisateur, Symfony chargera les informations de l'utilisateur depuis quelque part. C'est ce qu'on appelle le « fournisseur d'utilisateurs » et il est de votre responsabilité de le configurer. Symfony dispose d'un moyen intégré pour charger les utilisateurs depuis la base de données, mais il est également possible de créer votre propre fournisseur d'utilisateurs.

Le moyen le plus simple (mais avec de nombreuses limitations) est de configurer Symfony pour charger directement les utilisateurs qui y sont programmés à partir du fichier security.yml. C'est ce qu'on appelle un fournisseur "en mémoire", mais il est préférable de le considérer comme un fournisseur "en configuration" security.yml 文件里直接加载写死在其中的用户。这被称为“in memory” provider，但把它观想为“in configuration” provider更合适些

$  php bin/console security:encode-password

PHP:// app/config/security.php$container->loadFromExtension('security', array(
    // ...     'providers' => array(
        'in_memory' => array(
            'memory' => array(
                'users' => array(
                    'ryan' => array(
                        'password' => 'a$LCY0MefVIEc3TYPHV9SNnuzOfyr2p/AXIGoQJEDs4am4JwhNz/jli',
                        'roles' => 'ROLE_USER',
                    ),
                    'admin' => array(
                        'password' => 'a$cyTWeE9kpq1PjqKFiWUZFuCRPwVyAZwm4XzMZ1qPUFl7/flCM3V0G',
                        'roles' => 'ROLE_ADMIN',
                    ),
                ),
            ),
        ),
    ),
    // ...));

XML:<!-- app/config/security.xml --><?xml version="1.0" encoding="UTF-8"?><srv:container xmlns="http://Symfony.com/schema/dic/security"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:srv="http://Symfony.com/schema/dic/services"    xsi:schemaLocation="http://Symfony.com/schema/dic/services        http://Symfony.com/schema/dic/services/services-1.0.xsd">     <config>
        <!-- ... -->         <provider name="in_memory">
            <memory>
                <user name="ryan" password="a$LCY0MefVIEc3TYPHV9SNnuzOfyr2p/AXIGoQJEDs4am4JwhNz/jli" roles="ROLE_USER" />
                <user name="admin" password="a$cyTWeE9kpq1PjqKFiWUZFuCRPwVyAZwm4XzMZ1qPUFl7/flCM3V0G" roles="ROLE_ADMIN" />
            </memory>
        </provider>
    </config></srv:container>

类似 firewalls，你可以拥有多个 providers ，但你几乎只需要一个。如果你确实 拥有多个，你可以在防火墙的 provider 键（如 provider：in_memory

YAML:# app/config/security.ymlsecurity:    # ...
    providers:
        in_memory:
            memory:
                users:
                    ryan:
                        password: a$LCY0MefVIEc3TYPHV9SNnuzOfyr2p/AXIGoQJEDs4am4JwhNz/jli
                        roles: 'ROLE_USER'
                    admin:
                        password: a$cyTWeE9kpq1PjqKFiWUZFuCRPwVyAZwm4XzMZ1qPUFl7/flCM3V0G
                        roles: 'ROLE_ADMIN'

PHP:// app/config/security.php$container->loadFromExtension('security', array(
    // ...     'firewalls' => array(
        // ...
        'default' => array(
            // ...
        ),
    ),
   'access_control' => array(
       // require ROLE_ADMIN for /admin*
        array('path' => '^/admin', 'role' => 'ROLE_ADMIN'),
    ),));

XML:<!-- app/config/security.xml --><?xml version="1.0" encoding="UTF-8"?><srv:container xmlns="http://Symfony.com/schema/dic/security"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:srv="http://Symfony.com/schema/dic/services"    xsi:schemaLocation="http://Symfony.com/schema/dic/services        http://Symfony.com/schema/dic/services/services-1.0.xsd">     <config>
        <!-- ... -->         <firewall name="default">
            <!-- ... -->
        </firewall>         <!-- require ROLE_ADMIN for /admin* -->
        <rule path="^/admin" role="ROLE_ADMIN" />
    </config></srv:container>

Essayez de vous connecter avec le nom d'utilisateur admin et le mot de passe kitten. Vous devriez voir une erreur ! admin 和密码 kitten 来登录。你应该看到一个错误！

No encoder has been configured for account "SymfonyComponentSecurityCoreUserUser"

要修复此问题 ，添加一个 encoders 健：

YAML:# app/config/security.ymlsecurity:    # ...
    firewalls:        # ...
        default:            # ...
    access_control:        # require ROLE_ADMIN for /admin*
        - { path: ^/admin, roles: ROLE_ADMIN }

PHP:// app/config/security.php$container->loadFromExtension('security', array(
    // ...     'access_control' => array(
        array('path' => '^/admin/users', 'role' => 'ROLE_SUPER_ADMIN'),
        array('path' => '^/admin', 'role' => 'ROLE_ADMIN'),
    ),));

XML:<!-- app/config/security.xml --><?xml version="1.0" encoding="UTF-8"?><srv:container xmlns="http://Symfony.com/schema/dic/security"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:srv="http://Symfony.com/schema/dic/services"    xsi:schemaLocation="http://Symfony.com/schema/dic/services        http://Symfony.com/schema/dic/services/services-1.0.xsd">     <config>
        <!-- ... -->         <rule path="^/admin/users" role="ROLE_SUPER_ADMIN" />
        <rule path="^/admin" role="ROLE_ADMIN" />
    </config></srv:container>

User providers加载用户信息，并将其置于一个 User 对象中。如果你从数据库中加载用户 或者 从其他来源加载，你需要使用自定义的User类。但当你使用“in memory” provider时，它直接给了你一个 SymfonyComponentSecurityCoreUserUser 对象。

无论你使用什么样的User类，你都需要去告诉Symfony它们的密码加密算法是什么。在本例中，密码只是明文的文本，但很快，你要把它改成 bcrypt。

如果你现在刷新，你就会登录进来！web除错工具栏会告诉你，你是何人，你的roles（角色）是什么：

由于此URL需要的是 ROLE_ADMIN ，如果你登录的是 ryan 用户，将被拒绝访问。更多内容参考后面的 [URL受到保护的条件（access_control](#catalog9）。

从数据库加载用户 ¶

如果你想通过Doctrine Orm加载用户，很容易！参考 如何从数据库中(Entity Provider)加载Security系统之用户 以了解全部细节。

C) 对用户密码进行加密 ¶

不管用户是存储在 security.yml 里，数据库里还是其他地方，你都需要去加密其密码。堪用的最好算法是 bcrypt

Aucun encodeur n'a été configuré pour le compte "SymfonyComponentSecurityCoreUserUser"

YAML:# app/config/security.ymlsecurity:    # ...
    access_control:
        - { path: ^/admin/users, roles: ROLE_SUPER_ADMIN }
        - { path: ^/admin, roles: ROLE_ADMIN }

// ... public function helloAction($name){
    // The second parameter is used to specify on what object the role is tested.
    // 第二个参数用于指定“要将role作用到什么对象之上”
    $this->denyAccessUnlessGranted('ROLE_ADMIN', null, 'Unable to access this page!');     // Old way / 老办法:
    // if (false === $this->get('security.authorization_checker')->isGranted('ROLE_ADMIN')) {
    //     throw $this->createAccessDeniedException('Unable to access this page!');
    // }     // ...}

// ...use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security; /**
 * @Security("has_role('ROLE_ADMIN')")
 */public function helloAction($name){
    // ...}

Quelle que soit la classe d'utilisateurs que vous utilisez, vous devez indiquer à Symfony quel est son algorithme de cryptage de mot de passe. Dans ce cas, le mot de passe n'est qu'un texte en clair, mais vous souhaiterez bientôt le changer en bcrypt.

Si vous actualisez maintenant, vous serez connecté ! La barre d'outils de débogage Web vous dira qui vous êtes et quels sont vos rôles :

Puisque cette URL nécessite ROLE_ADMIN, si vous L'utilisateur connecté est ryan et l'accès lui sera refusé. Pour plus d'informations, veuillez vous référer aux [URL protégées conditions (access_control](#catalog9).

Charger les utilisateurs depuis la base de données ¶

Si vous souhaitez charger des utilisateurs via Doctrine Orm, c'est simple ! Reportez-vous à Comment charger les utilisateurs de la base de données (Entity Provider)Charger l'utilisateur du système de sécurité pour connaître tous les détails # 🎜🎜# Bien entendu, le mot de passe de l'utilisateur doit maintenant être crypté par cet algorithme spécifié. Pour les utilisateurs codés en dur (dans config.yml), vous pouvez le faire avec la commande intégrée : ## 🎜🎜#

PHP:<?php if ($view['security']->isGranted(new Expression(
    '"ROLE_ADMIN" in roles or (user and user.isSuperAdmin())'))): ?>
    <a href="...">Delete</a><?php endif; ?>

C) Crypter le mot de passe de l'utilisateur ¶< /a> Que l'utilisateur soit stocké dans security.yml, dans la base de données ou ailleurs, vous devez chiffrer son mot de passe. Le meilleur algorithme à utiliser est bcrypt : PHP:<?php if ($view['security']->isGranted('ROLE_ADMIN')): ?>     <a href="...">Delete</a><?php endif ?> Twig:{% if is_granted('ROLE_ADMIN') %}     <a href="...">Delete</a>{% endif %}

if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {         throw $this->createAccessDeniedException();     }     // ...}

#🎜🎜##🎜🎜##🎜🎜#

Twig:{% if is_granted(expression(
    '"ROLE_ADMIN" in roles or (user and user.isSuperAdmin())')) %}
    <a href="...">Delete</a>{% endif %}

#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#

Cela vous apportera quelque chose comme ceci (le mot de passe est crypté) :

public function indexAction(){
    if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
        throw $this->createAccessDeniedException();
    }     $user = $this->getUser();     // the above is a shortcut for this / 上面的写法是通过以下取法（再进行授权）的快捷方式
    $user = $this->get('security.token_storage')->getToken()->getUser();}

use Symfony\Component\HttpFoundation\Response;
// ... public function indexAction(){
  // ...     return new Response('Well hi there '.$user->getFirstName());}

public function indexAction(UserInterface $user = null){
    // $user is null when not logged-in or anon.
    // 当用户没有登陆，或者是anno.时，$user是null}

Maintenant, tout est comme avant. Mais si vous avez des utilisateurs dynamiques (par exemple, dans une base de données) dont les mots de passe sont chiffrés avant d'être stockés dans la base de données, comment pouvez-vous les chiffrer par programme ? Ne vous inquiétez pas, reportez-vous à Crypter le mot de passe manuellement pour plus de détails.

D) Configuration terminée ! ¶

Félicitations ! Vous disposez désormais d'un "système d'authentification" fonctionnel basé sur l'authentification de base HTTP et chargeant les utilisateurs à partir du fichier security.yml. security.yml 文件中加载用户的“验证系统”了。

根据你的设置，尚有后续步骤：

• 配置用户登录的不同方式，例如 登录表单 或者 某些完全自定义的；

• 从不同来源来加载用户，例如 数据库 或者 其他源头；

• 在 授权 小节了解如何拒绝访问（deny access）、加载用户对象，以及操作Roles；

2) 拒绝访问,Roles和其他授权方式 ¶

现在，用户可以通过 http_basic 或者其他方式来登录你的程序。了不起呀！现在你需要学习如何拒绝访问（deny access）并且能与User对象一起工作。这被称为authorization（授权），它的工作是决定用户是否可以访问某些资源（如一个URL、一个model对象、一个被调用的方法等...）。

授权过程分为两个不同的方面：

1. 用户在登录时收到一组特定的Roles（角色。如 ROLE_ADMIN）。

2. 你添加代码，以便某个资源（例如url、控制器）需要一个特定“属性”（多数时候就是一个类似 ROLE_ADMIN 的role）才能被访问到。

🎜 dans

2) Refuser l'accès, les rôles et autres méthodes d'autorisation ¶🎜

🎜Désormais, les utilisateurs peuvent se connecter à votre programme via http_basic ou d'autres méthodes. Incroyable! Vous devez maintenant apprendre à refuser l'accès et à utiliser des objets utilisateur. C'est ce qu'on appelle une autorisation (autorisation), et son rôle est de déterminer si l'utilisateur peut accéder à certaines ressources (comme une URL, un objet modèle, une méthode appelée, etc...). 🎜🎜Le processus d'autorisation est divisé en deux aspects différents : 🎜

1. 🎜Les utilisateurs reçoivent un ensemble spécifique de rôles (rôles. Tels que ROLE_ADMIN) lors de la connexion. 🎜
2. 🎜Vous ajoutez du code pour qu'une ressource (par exemple, une URL, un contrôleur) nécessite un "attribut" spécifique (principalement un rôle comme ROLE_ADMIN) avant de pouvoir y accéder. 🎜

🎜En plus des rôles (tels que ROLE_ADMIN ), vous pouvez également utiliser d'autres attributs/chaînes (tels que EDIT) pour protéger une ressource et la rendre efficace en utilisant des électeurs ou le système ACL de Symfony. Ceci est extrêmement utile lorsque vous devez vérifier si l'utilisateur A peut "modifier" l'objet B (par exemple, un produit avec l'identifiant 5). Référence 🎜Listes de contrôle d'accès (ACL) : Protection des objets de base de données individuels🎜. 🎜🎜🎜

Rôles/rôles ¶

Lorsqu'un utilisateur se connecte, il recevra un ensemble de rôles (tels que ROLE_ADMIN). Dans l'exemple ci-dessus, ces (rôles) sont codés en dur dans security.yml. Si vous chargez des utilisateurs depuis la base de données, ils doivent être stockés dans une colonne du tableau. ROLE_ADMIN）。在上例中，这些(roles)都被写死到 security.yml 中了。如果你从数据库中加载用户，它们应该存在了表的某一列中。

你要分给一个用户的所有roles，一定要以 ROLE_ 前缀开始。否则，它们不会被Symfony的Security系统按常规方式来操作（除非使用高级手段，否则你把 FOO 这样的role分给一个用户，然后像 下面这样 去检查 FOO 是行不通的）。

roles很简单，而且基本上都是你根据需要自行创造的字符串。例如，如果你打算限制访问你网站博客的admin部分，可以使用ROLE_BLOG_ADMIN 这个role来进行保护。role毋须在其他地方定义－你就可以开始用它了。

确保每个用户至少有一个 角色，否则他们会被当作未验证之人。常见的做法就是给每个 普通用户一个 ROLE_USER。

你还可以指定role层级，此时，拥有某些roles意味着你同时拥有了其他的roles。

添加代码以拒绝访问 ¶

要拒绝访问（deny access）某些东东，有两种方式可以实现：

• 使用security.yml中的access_control，即可使用URL的条件保护（如 /admin/*）。这虽然容易，但灵活性不足；

• 在代码中使用 security.authorization_checker 服务；

通过条件匹配来保护URL（access_control） ¶

对程序的某一部分进行保护时的最基本方法是对URL进行完整的条件匹配。之前你已看到，任何匹配了正则表达式 ^/admin 的页面都需要 ROLE_ADMIN

Tous les rôles que vous souhaitez attribuer à un utilisateur doivent commencer par le préfixe ROLE_ . Sinon, ils ne seront pas exploités par le système de sécurité de Symfony de la manière normale (sauf si vous utilisez des moyens avancés, sinon vous attribuez un rôle comme FOO à un utilisateur, puis comme Vérifier FOO comme ça

ne fonctionnera pas).

les rôles sont très simples et ce sont essentiellement des chaînes que vous créez en fonction de vos besoins. Par exemple, si vous envisagez de restreindre l'accès à la section d'administration du blog de votre site Web, vous pouvez utiliser le rôle ROLE_BLOG_ADMIN pour la protéger. Le rôle n'a pas besoin d'être défini ailleurs : vous pouvez simplement commencer à l'utiliser.

Assurez-vous que chaque utilisateur a au moins un rôle, sinon il sera traité comme inconnu La personne qui valide. Une approche courante consiste à attribuer à chaque utilisateur ordinaire un ROLE_USER.

🎜Vous pouvez également spécifier le niveau du rôle. À l'heure actuelle, posséder certains rôles signifie que vous possédez également d'autres rôles. 🎜🎜Ajoutez un code pour refuser l'accès ¶🎜🎜🎜Pour refuser l'accès à quelque chose, il existe deux typesCela peut être réalisé par : 🎜

• 🎜Utilisez access_control🎜 dans security.yml, vous pouvez utiliser la protection conditionnelle de l'URL (telle que /admin/* ). C'est simple, mais pas très flexible 🎜
• 🎜Utilisez le service security.authorization_checker dans votre code 🎜

; Correspondance conditionnelle réussie pour protéger l'URL (access_control) ¶🎜

🎜La méthode la plus élémentaire pour protéger une certaine partie du programme est de protéger la correspondance de condition URL complète. Comme vous l'avez vu précédemment, toute page correspondant à l'expression régulière ^/admin nécessite ROLE_ADMIN : 🎜

// yay! Use this to see if the user is logged in// 耶！使用这个来查看用户是否已登陆if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
    throw $this->createAccessDeniedException();} // boo :(. Never check for the User object to see if they're logged in// 哄！:(. 切勿通过检查User对象来判断用户是否已登陆if ($this->getUser()) { }

PHP:<?php if ($view['security']->isGranted('IS_AUTHENTICATED_FULLY')): ?>
    <p>Username: <?php echo $app->getUser()->getUsername() ?></p><?php endif; ?>

🎜🎜🎜🎜🎜

Twig:{% if is_granted('IS_AUTHENTICATED_FULLY') %}
    <p>Username: {{ app.user.username }}</p>{% endif %}

🎜🎜🎜🎜🎜

C'est bien de pouvoir protéger toute la zone (à laquelle appartient l'URL), mais vous souhaiterez peut-être aussi protéger une action spécifique du contrôleur.

Vous pouvez définir autant de conditions de correspondance d'URL que vous le souhaitez - chaque condition est une expression régulière. Mais , un seul un sera jumelé. Symfony commencera à regarder en haut (dans le fichier) et terminera dès qu'il trouvera une entrée dans access_control qui correspond à l'URL. access_control 中的某个入口与URL相匹配，就立即结束。

PHP:// app/config/security.php$container->loadFromExtension('security', array(
    // ...     'firewalls' => array(
        'secured_area' => array(
            // ...
            'logout' => array('path' => '/logout', 'target' => '/'),
        ),
    ),));

Twig:<!-- app/config/security.xml --><?xml version="1.0" encoding="UTF-8"?><srv:container xmlns="http://Symfony.com/schema/dic/security"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:srv="http://Symfony.com/schema/dic/services"    xsi:schemaLocation="http://Symfony.com/schema/dic/services        http://Symfony.com/schema/dic/services/services-1.0.xsd">     <config>
        <!-- ... -->         <firewall name="secured_area">
            <!-- ... -->
            <logout path="/logout" target="/" />
        </firewall>
    </config></srv:container>

YAML:# app/config/security.ymlsecurity:    # ...
    firewalls:
        secured_area:            # ...
            logout:
                path:   /logout
                target: /

在path中加了一个 ^ 是指，仅当URL“按照正则条件那样起头”时，才会匹配到。例如，一个path若只有 /admin（不包含 ^）则会匹配到 /admin/foo 但同时也匹配了 /foo/admin 这种。

理解access_control是如何工作的

access_control 部分异常强大，但如果你不明白它的工作原理，它也会很危险（毕竟涉及到安全性）。 access_control 除了匹配URL，还可匹配IP地址、主机名和HTTP method。它也可以用于将用户重定向到 https 版本的URL条件中去。

要了解这一切，参考 Security的access_control是如何工作的。

保护控制器和代码中的其他部分 ¶

在控制器中你可以轻松谢绝访问：

PHP:// app/config/routing.phpuse Symfony\Component\Routing\RouteCollection;use Symfony\Component\Routing\Route; $collection = new RouteCollection();$collection->add('logout', new Route('/logout')); return $collection;

两种情况下，一个特殊的 AccessDeniedException 会被抛出，这最终触发了Symfony内部的一个403 HTTP响应。

就是这样！如果是尚未登录的用户，他们会被要求登录（如，重定向到登录页面）。如果他们已经 登录，但不具备 ROLE_ADMIN 角色，则会被显示403拒绝访问页面（此页可以 自定义）。如果他们已登录同时拥有正确的roles，代码就会继续执行。

多亏了SensioFrameworkExtraBundle，你可以在控制器中使用annotations

XML:<!-- app/config/routing.xml --><?xml version="1.0" encoding="UTF-8" ?><routes xmlns="http://Symfony.com/schema/routing"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://Symfony.com/schema/routing        http://Symfony.com/schema/routing/routing-1.0.xsd">     <route id="logout" path="/logout" /></routes>

参考 FrameworkExtraBundle 以了解更多。

模版中的访问控制 ¶

如果你想在模版中检查当前用户是否具有一个role，可以使用内置的 is_granted()

YAML:# app/config/routing.ymllogout:
    path: /logout

PHP:// app/config/security.php$container->loadFromExtension('security', array(
    // ...     'role_hierarchy' => array(
        'ROLE_ADMIN'       => 'ROLE_USER',
        'ROLE_SUPER_ADMIN' => array(
            'ROLE_ADMIN',
            'ROLE_ALLOWED_TO_SWITCH',
        ),
    ),));

XML:<!-- app/config/security.xml --><?xml version="1.0" encoding="UTF-8"?><srv:container xmlns="http://Symfony.com/schema/dic/security"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:srv="http://Symfony.com/schema/dic/services"    xsi:schemaLocation="http://Symfony.com/schema/dic/services        http://Symfony.com/schema/dic/services/services-1.0.xsd">     <config>
        <!-- ... -->         <role id="ROLE_ADMIN">ROLE_USER</role>
        <role id="ROLE_SUPER_ADMIN">ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH</role>
    </config></srv:container>

L'ajout d'un ^ au chemin signifie qu'il ne sera mis en correspondance que si l'URL "démarre selon les conditions habituelles". Par exemple, si un chemin ne contient que /admin (sans ^), il correspondra à /admin/foo mais aussi à . foo/admin Ce genre de. 🎜

Comprendre comment fonctionne access_control

🎜 Le access_control La partie est incroyablement puissante, mais elle peut aussi être dangereuse si vous ne comprenez pas comment elle fonctionne (la sécurité est impliquée, après tout). access_control En plus de faire correspondre les URL, il peut également faire correspondre les adresses IP, les noms d'hôte et les méthodes HTTP. Il peut également être utilisé pour rediriger les utilisateurs vers la version https de la condition d'URL. 🎜🎜Pour comprendre tout cela, reportez-vous à Comment fonctionne le contrôle d'accès de Security🎜. 🎜🎜🎜

Protégez les contrôleurs et d'autres parties de votre code ¶🎜

🎜Dans les contrôleurs, vous pouvez facilement refuser l'accès : 🎜

YAML:# app/config/security.ymlsecurity:    # ...
    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: [ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]

🎜Dans les deux cas, un AccessDeniedException🎜 sera levée, ce qui déclenchera finalement une réponse HTTP 403 au sein de Symfony.
🎜🎜Ça y est ! Si l'utilisateur n'est pas encore connecté, il lui sera demandé de se connecter (par exemple, redirigé vers la page de connexion). S'ils sont déjà connectés mais n'ont pas le rôle ROLE_ADMIN, une page 403 Accès refusé leur sera présentée (cette page peut custom 🎜). S'ils sont connectés et disposent des rôles corrects, le code continuera à s'exécuter. 🎜🎜Grâce à SensioFrameworkExtraBundle, vous pouvez utiliser des annotations dans les contrôleurs🎜rrreee🎜Référez-vous à FrameworkExtraBundle🎜 pour en savoir plus.
🎜

Contrôle d'accès dans les modèles ¶🎜

🎜Si vous souhaitez vérifier dans le modèle si l'utilisateur actuel a un rôle, vous pouvez utiliser la fonction d'assistance intégrée is_granted() : 🎜rrreee🎜rrreee🎜

Protégez d'autres services ¶

Si vous écrivez un code similaire comme "Protect Controller", n'importe où dans Symfony peut être protégé. Disons que vous disposez d'un service (c'est-à-dire une classe php) pour envoyer des e-mails. Vous pouvez restreindre l'utilisation de cette classe - quel que soit l'endroit où elle est utilisée - à des utilisateurs spécifiques uniquement.

Référez-vous à Comment protéger les services et les méthodes dans un programme pour en savoir plus.

Vérifiez si l'utilisateur est connecté (IS_AUTHENTICATED_FULLY) ¶

Jusqu'à présent, vous avez vérifié l'accès basé sur les rôles - ces chaînes commençant par le préfixe ROLE_ qui sont attribuées aux utilisateurs. Cependant, si vous ROLE_ 前缀开头的字符串，被分配给了用户。但是，如果你只 想检查用户是否登录（并不关心什么role不role的），那么你可以使用 IS_AUTHENTICATED_FULLY：// ... public function helloAction($name){

rrreee

你当然也可以使用在 access_control 中使用它。

IS_AUTHENTICATED_FULLY 不是一个role，但是它的某些行为又像是role，并且每个成功登录的用户都有这么一个。事实上，类似的特殊属性共有三个：

• IS_AUTHENTICATED_REMEMBERED：所有 已登录用户都有它，哪怕他们是通过“remember me cookie”登录进来的。就算你并没有使用 remember me功能，你依然能够通过这个属性来检查用户是否已经登录。

• IS_AUTHENTICATED_FULLY：类似于 IS_AUTHENTICATED_REMEMBERED ，但更健壮。那些仅凭 “remember me cookie”中的 IS_AUTHENTICATED_REMEMBERED 登录进来的用户，并不会拥有 IS_AUTHENTICATED_FULLY 。

• IS_AUTHENTICATED_ANONYMOUSLY seulement souhaitez vérifier si l'utilisateur est connecté (et ne vous souciez pas de son rôle), alors vous pouvez utiliser IS_AUTHENTICATED_FULLY : // ... fonction publique helloAction($name){rrreee

  Vous pouvez bien sûr également l'utiliser dans access_control.

  IS_AUTHENTICATED_FULLY n'est pas un rôle, mais certains de ses comportements sont comme des rôles, et chaque utilisateur qui se connecte avec succès a un tel rôle. En fait, il existe trois attributs spéciaux similaires :
IS_AUTHENTICATED_REMEMBERED :

Tous

les utilisateurs connectés l'ont, même s'ils se sont connectés via le "cookie de mémorisation" . Même si vous n'utilisez pas la fonction se souvenir de moi
, vous pouvez toujours vérifier si l'utilisateur est connecté via cet attribut.
🎜
• 🎜IS_AUTHENTICATED_FULLY : similaire à IS_AUTHENTICATED_REMEMBERED, mais plus robuste. Les utilisateurs qui se connectent avec seulement IS_AUTHENTICATED_REMEMBERED dans le "cookie de mémorisation" n'auront pas IS_AUTHENTICATED_FULLY. 🎜🎜
• 🎜IS_AUTHENTICATED_ANONYMOUSLY : 🎜Tous les 🎜 utilisateurs (même les utilisateurs anonymes) ont cet attribut - il est utile lorsque vous mettez une URL dans une 🎜liste blanche🎜 pour garantir qu'elle est accessible. Reportez-vous à 🎜Comment fonctionne le contrôle d'accès de la sécurité🎜 pour en savoir plus. 🎜🎜🎜🎜Vous pouvez également utiliser des expressions dans les modèles : 🎜rrreee🎜rrreee🎜

  Pour plus de détails sur les expressions et la sécurité, reportez-vous à Sécurité : expressions de contrôles d'accès complexes .

  Listes de contrôle d'accès (ACL) : protection des objets de base de données individuels ¶

  Imaginez que vous concevez un blog, les utilisateurs peuvent laisser des commentaires ci-dessous le sujet. Vous souhaitez également que les utilisateurs puissent modifier leurs propres commentaires, mais pas les autres utilisateurs. De plus, en tant qu'utilisateur administrateur, vous souhaiterez pouvoir modifier tous les commentaires.

  Pour ce faire, vous avez deux options :

  • Voteurs Autoriser les utilisateurs à écrire leur propre logique métier (par exemple, l'utilisateur peut modifier ce message car il en est le créateur) pour vérifier l'accès. Vous pouvez utiliser cette option – elle est suffisamment flexible pour résoudre les problèmes ci-dessus. Les

  • ACL vous permettent de créer une structure de base de données dans laquelle vous pouvez attribuer à n'importe quelutilisateur n'importe queldroit d'accès (par exemple, EDITER, VIEW) à n'importe quelobjet. Pour utiliser les ACL, vous avez besoin d'un utilisateur administrateur pour accorder un accès personnalisé à votre système via une interface d'administration.

  Dans les deux cas, vous devez toujours utiliser une méthode similaire à l'exemple précédent pour implémenter le refus d'accès.

  Obtenir l'objet utilisateur ¶

  Après vérification, vous pouvez accéder à l'objet Utilisateur de l'utilisateur actuel via le service security.token_storage. Dans le contrôleur, écrivez ceci : security.token_storage 服务来访问当前用户的 User 对象。在控制器内，这样写：

  rrreee

  
  

  用户将是一个对象，该对象所属的类，则取决于你的user provider。

  
  

  3.2通过方法签名（method signature）来取得用户的功能，是从Symfony 3.2开始引入的。如果你继承了 Controller，则仍然可以通过调用 $this->getUser()rrreee

  
  
  🎜L'utilisateur sera un objet, et la classe à laquelle appartient l'objet dépend de votre fournisseur d'utilisateurs🎜. 🎜🎜🎜
  🎜

  🎜3.2 L'obtention de fonctions utilisateur via des signatures de méthode a été introduite à partir de Symfony 3.2 . Si vous héritez de Controller🎜 , il peut toujours être obtenu en appelant $this->getUser(). 🎜🎜

  Maintenant, n'importe quelle méthode peut être appelée en fonction de votre objet Utilisateur. Par exemple, s'il existe une méthode getFirstName() dans l'objet User, vous pouvez l'utiliser : getFirstName() 方法，你可以使用它：

  rrreee

  始终检测用户是否登录 ¶
  

  对用户的初次验证十分重要。如果未登陆，$user 就是 null 或者 anon. 字符串之一。等一下，为什么呢？是的，这很奇怪。如果你没有登录，严格来讲，用户应该是 anon.，尽管控制器中的 getUser() 快捷方法会出于方便将其转变为 null。当使用 UserInterface 的类型提示并且登入（being logged in）是可选的时候，你可以为参数配置null值：

  rrreee

  观点是这样的：在使用User对象之前应该始终检查用户是否已登录，可使用 isGranted 方法（或 access_control）来完成：
  

  rrreee

  在模版中获取用户 ¶
  

  对象在twig模版中可以使用app.user键：

  rrreeerrreee

  Logging out/退出登录 ¶
  

  注意，当使用http-basic验证方式的防火墙时，是没有办法退出的：log out 的唯一方式就是令浏览器停止在每次请求中发送你的用户名和密码。清除浏览器缓存或重启它，往往有用。某些web开发工具（译注：可能是指浏览器的f12）也可能有用。

  通常情况下，你希望用户能够注销。幸运的是，当你激活 logoutrrreee

  Toujours détecter si l'utilisateur est connecté ¶

  
  

  La vérification initiale de l'utilisateur est très importante. Si vous n'êtes pas connecté, $user est l'une des chaînes null ou anon.. Attends, pourquoi ? Oui, c'est bizarre. Si vous n'êtes pas connecté, techniquement, l'utilisateur doit être anon., bien que la méthode de raccourci getUser() dans le contrôleur le convertira en pour plus de commodité null< /code>. Lorsque vous utilisez Lorsque UserInterface est indiqué et que la connexion est facultative, vous pouvez configurer une valeur nulle pour le paramètre :

  rrreee

  Le point est le suivant : vous devez toujours vérifier l'utilisateur avant d'utiliser le Objet Utilisateur Que vous soyez connecté ou non, vous pouvez utiliser la méthode isGranted (ou access_control) pour compléter : 🎜🎜rrreee🎜Obtenir l'utilisateur dans le modèle ¶🎜🎜🎜 les objets peuvent être utilisés dans les modèles de brindillesapp.userClé : 🎜rrreeerrreee🎜Déconnexion/Déconnexion ¶🎜🎜

  🎜Notez que lors de l'utilisation d'un pare-feu avec authentification http-basic, il n'y a aucun moyen de quitter : 🎜log La seule façon de sortir 🎜 est de faire en sorte que le navigateur arrête d'envoyer votre nom d'utilisateur et votre mot de passe à chaque demande. Vider le cache du navigateur ou le redémarrer est souvent utile. Certains outils de développement web peuvent également être utiles. 🎜🎜🎜🎜En règle générale, vous souhaitez que l'utilisateur puisse se déconnecter. Heureusement, lorsque vous activez le paramètre de configuration logout, le pare-feu peut vous aider à le gérer automatiquement : 🎜rrreeerrreeerrreee🎜 Ensuite, vous devez créer une route pour cette URL (mais aucun contrôleur n'est requis) : 🎜 🎜 rrreeerrree🎜rrree🎜

  C'est tout ! En envoyant l'utilisateur vers /logout (ou toute option path que vous configurez), Symfony désauthentifiera l'utilisateur actuel. /logout （或者你任意配置的 path 选项），Symfony将取消当前用户的验证信息。

  一旦用户被注销，他们会被重定向到已经定义的 target 参数所对应的路径中（如 homepage）。

  如果你需要在注销后做一些更有趣的事，可以通过添加 success_handler 键来指定一个“登出成功控制器”（logout success handler），将它填写成一个服务定义之id，该服务的class必须实现 LogoutSuccessHandlerInterface接口。参考 Security Configuration Reference。

  按等级划分的Roles ¶

  并非把大量roles统统关联到用户，通过创建role hierarchy（角色层级），你可以定义一套“角色继承规则”：

  rrreeerrreee

  rrreee

  在上面的配置中，用户 ROLE_ADMIN 也将具备 ROLE_USER role。ROLE_SUPER_ADMIN role，同时拥有 ROLE_ADMIN，ROLE_ALLOWED_TO_SWITCH 以及 ROLE_USER（继承自 ROLE_ADMIN

  Une fois l'utilisateur déconnecté, il sera redirigé vers le chemin correspondant au paramètre target défini (tel que page d'accueil).

  Si vous avez besoin de faire quelque chose de plus intéressant après vous être déconnecté, vous pouvez ajouter success_handler clé pour spécifier un "gestionnaire de réussite de déconnexion" et remplissez-le avec l'identifiant d'une définition de service. La classe du service doit implémenter LogoutSuccessHandlerInterfaceinterface. Référence

  Référence de configuration de sécurité

  .

  Rôles par niveau ¶

  Au lieu d'associer un grand nombre de rôles aux utilisateurs, en créant une hiérarchie de rôles, vous pouvez définir un ensemble de "règles d'héritage de rôle" :

  rrreeerrreee

  rrreee

  Dans la configuration ci-dessus, l'utilisateur ROLE_ADMIN aura également ROLE_USER< /code > rôle. Rôle ROLE_SUPER_ADMIN, qui possède également ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH et ROLE_USER (hérité de ROLE_ADMIN ) .

  Résumé 🎜¶🎜🎜🎜Oh~ Bravo ! Vous avez appris bien plus que les bases de la sécurité. Le plus difficile, c'est lorsque vous avez des exigences personnalisées : comme définir une stratégie d'authentification (par exemple, des jetons API), une logique d'autorisation complexe et bien d'autres choses (car la sécurité est intrinsèquement complexe !). 🎜🎜Heureusement : il existe ici de nombreux articles qui visent à clarifier diverses situations. En attendant, référez-vous au 🎜Référence de sécurité🎜. De nombreuses options de configuration ne sont pas détaillées, mais il est néanmoins utile de voir l'arborescence de configuration complète. 🎜🎜Bonne chance ! 🎜🎜🎜🎜🎜🎜

  ← performance

  Comment utiliser le sérialiseur →

soumettre

Site Web PHP chinois

MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger