l-1

PHP笔记

主页/PHP笔记/PHP问答/框架Symfony/在Symfony中实施授权：开发者指南

在Symfony中实施授权：开发者指南

Bug编译狮

Bug编译狮

《在Symfony中实现授权：开发者指南》

在现代Web开发中，安全性和权限控制是至关重要的。Symfony框架提供了强大的工具和模块来帮助开发者轻松地实现这些功能。以下是一些关键步骤和最佳实践，帮助你在Symfony项目中实施授权。

1. 安装并配置GuardBundle

首先，你需要安装FOSUserBundle和FOSGuardBundle，这是Symfony Security的一部分。

composer require friendsofsymfony/user-bundle fos/guard-bundle

然后，配置这两个Bundle：

config/bundles.php

return [
    // 其他Bundle...

    FOSUserBundleFOSUserBundle::class => ['all' => true],
    FOSGuardBundleFOSGuardBundle::class => ['all' => true],
];

config/packages/security.yaml

security:
    encoders:
        app_user: bcrypt

    providers:
        user_provider:
            entity:
                class: AppEntityUser
                property: username

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

        main:
            anonymous: ~
            guard:
                authenticators:
                    - AppSecurityAuthenticationFOSAuthenticator::class
            logout:
                path: /logout
            remember_me:
                secret: 'your_secret_key'
                lifetime: 604800 # 7 days in seconds
                path: /
            form_login:
                login_path: /login
                success_handler: AppControllerSecurityController::handleLoginSuccess
                failure_handler: AppControllerSecurityController::handleLoginFailure
                check_path: /login_check
                default_target_path: /
            logout_url: /logout
            access_control:
                - { path: ^/, roles: ROLE_USER }

2. 创建用户实体和角色

在src/Entity目录下创建用户实体类，并定义角色：

// src/Entity/User.php

use DoctrineORMMapping as ORM;
use SymfonyComponentSecurityCoreUserUserInterface;

/**
 * @ORMEntity(repositoryClass="AppRepositoryUserRepository")
 */
class User implements UserInterface
{
    /**
     * @ORMId
     * @ORMGeneratedValue(strategy="AUTO")
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="string", length=180, unique=true)
     */
    private $username;

    /**
     * @ORMColumn(type="string", length=255)
     */
    private $email;

    /**
     * @ORMColumn(type="boolean")
     */
    private $enabled = true;

    /**
     * @ORMColumn(type="json_array")
     */
    private $roles = [];

    // Getters and setters...
}

3. 配置路由和控制器

创建登录和注销路由，并编写相应的控制器来处理这些请求：

# config/routes.yaml

app_login:
    path: /login
    methods: [GET, POST]
    controller: AppControllerSecurityController::loginAction

app_logout:
    path: /logout
    methods: [POST]
// src/Controller/SecurityController.php

namespace AppController;

use SymfonyBundleFrameworkBundleControllerAbstractController;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentRoutingAnnotationRoute;
use SymfonyComponentSecurityCoreEncoderUserPasswordEncoderInterface;
use SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentSecurityHttpAuthenticationTokenUsernamePasswordToken;

class SecurityController extends AbstractController
{
    private $passwordEncoder;

    public function __construct(UserPasswordEncoderInterface $passwordEncoder)
    {
        $this->passwordEncoder = $passwordEncoder;
    }

    #[Route('/login', name: 'app_login')]
    public function loginAction(Request $request): Response
    {
        if ($this->isGranted('IS_AUTHENTICATED_FULLY')) {
            return $this->redirectToRoute('target_route');
        }

        $authenticationUtils = $this->get('security.authentication_utils');

        $error = $authenticationUtils->getLastAuthenticationError();
        $lastUsername = $authenticationUtils->getLastUsername();

        return $this->render('security/login.html.twig', [
            'last_username' => $lastUsername,
            'error'         => $error,
        ]);
    }

    #[Route('/login_check', name: 'app_login_check')]
    public function loginCheck(): void
    {
        throw new Exception('This is just a placeholder to prevent caching issues.');
    }

    #[Route('/logout', name: 'app_logout')]
    public function logoutAction(): void
    {
        // Perform any necessary actions before logging out
        $this->authenticateUser(null);
        $this->addFlash('notice', 'You have been logged out.');

        return $this->redirectToRoute('homepage');
    }

    private function authenticateUser(?UserInterface $user): void
    {
        if (!$user) {
            return;
        }

        $token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
        $this->container->get('security.token_storage')->setToken($token);

        if ($this->container->has('session')) {
            $session = $this->container->get('session');
            $session->set('_security_main', serialize($token));
        }
    }
}

4. 实现认证逻辑

在src/Security/Authentication/FOSAuthenticator.php中实现认证逻辑：

// src/Security/Authentication/FOSAuthenticator.php

namespace AppSecurityAuthentication;

use FOSUserBundleModelUserInterface;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentSecurityCoreAuthenticationSimpleFormAuthenticator;
use SymfonyComponentSecurityCoreExceptionAuthenticationException;
use SymfonyComponentSecurityCoreUserUserProviderInterface;
use SymfonyComponentHttpFoundationSessionSessionInterface;

class FOSAuthenticator extends SimpleFormAuthenticator
{
    private $userProvider;

    public function __construct(UserProviderInterface $userProvider)
    {
        $this->userProvider = $userProvider;
    }

    protected function getCredentials(Request $request): array
    {
        return [
            'username' => $request->get('username'),
            'password' => $request->get('password'),
        ];
    }

    protected function getUser($credentials, UserProviderInterface $userProvider): ?UserInterface
    {
        return $userProvider->loadUserByUsername($credentials['username']);
    }

    protected function checkCredentials($credentials, UserInterface $user): bool
    {
        return password_verify($credentials['password'], $user->getPassword());
    }

    protected function onAuthenticationSuccess(Request $request, UserInterface $user, string $firewallName): RedirectResponse
    {
        $session = $request->getSession();
        if ($session !== null) {
            $session->set('_security_' . $firewallName, serialize($this->createAuthenticatedToken($user, $firewallName)));
        }

        return new RedirectResponse($this->generateUrl('target_route'));
    }

    protected function onAuthenticationFailure(Request $request, AuthenticationException $exception): Response
    {
        return new RedirectResponse($this->generateUrl('app_login'), 302);
    }

    private function createAuthenticatedToken(UserInterface $user, string $firewallName): TokenInterface
    {
        $token = new UsernamePasswordToken($user, null, $firewallName, $user->getRoles());
        $token->setAttributes(['authenticated' => true]);
        return $token;
    }
}

5. 测试授权

最后，测试你的应用以确保授权功能正常工作。你可以通过访问不同的页面来验证用户是否能够访问受保护的内容。

通过以上步骤，你可以在Symfony项目中成功实现基本的授权功能。随着项目的扩展，你还可以进一步探索更多的授权策略和功能，如角色继承、权限管理等。

黑板Bug讲师

黑板Bug讲师

介绍

Symfony，一个强大的PHP框架，提供了一个全面的安全组件，使得开发者可以轻松处理应用程序的身份验证和授权问题。在这篇文章中，我们将详细介绍在Symfony项目中实现权限控制的过程。我们将探讨Symfony的授权系统，并提供实际代码示例以加深理解。

理解Symfony Security

Symfony 安全组件分为两个主要部分：认证和授权。认证部分负责确认用户身份，而授权部分则授予已认证用户的权限。本指南将重点介绍授权部分，假设用户已经通过认证。

Symfony的授权系统的核心组件包括“投票者”和“访问决策管理者”。投票者决定用户是否可以在资源上执行一个操作，而访问决策管理者则收集投票者的响应来做出最终的授权控制决策。

配置访问控制

实施授权的第一步是在访问控制方面进行配置。security.yaml文件。这是一份基本路线保护规则手册，简单明了。

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

该配置声明任何以…开头的路由都适用。/admin仅对具有“ROLE_ADMIN”角色的用户开放，以及以某些前缀开始的路由。/profile要求用户具有“ROLE_USER”角色。

创建选民

为了进一步细化授权检查，我们需要创建选民。选民让您能够根据涉及资源或对象的更复杂的安全规则来决定。

namespace AppSecurityVoter;

use SymfonyComponentSecurityCoreAuthorizationVoterVoter;
use SymfonyComponentSecurityCoreAuthenticationTokenTokenInterface;

class PostVoter extends Voter {
    // Define your supported attributes and post instance check
    protected function supports($attribute, $subject) {
        if (!in_array($attribute, ['EDIT', 'DELETE'])) {
            return false;
        }

        if (!$subject instanceof Post) {
            return false;
        }

        return true;
    }

    // Voter logic implementation
    protected function voteOnAttribute($attribute, $post, TokenInterface $token) {
        $user = $token->getUser();

        // Your custom logic to determine if the user can EDIT or DELETE the given Post instance
        return $user === $post->getUser();
    }
}

在定义之后，我们接下来会做什么？supportsandvoteOnAttribute在您的Voter类的方法中，您可以像以下方式在控制器操作中使用授权检查：

public function editAction(Request $request, Post $post) {
    $this->denyAccessUnlessGranted('EDIT', $post);

    // ... edit post
}

这。denyAccessUnlessGranted该方法将与投票者进行交互，以确保当前用户有权编辑帖子。

角色层级体系

Symfony 提供了一种简单的方法来定义您的角色层次结构。security.yaml这种层级结构允许某些角色自动拥有其他角色的所有权限。

security:
    role_hierarchy:
        ROLE_ADMIN: ROLE_USER
        ROLE_SUPER_ADMIN: ROLE_ADMIN

这意味着拥有“ROLE_SUPER_ADMIN”角色的用户将自动获得“ROLE_ADMIN”和“ROLE_USER”的权限。

保护服务

除了在控制器上控制访问，还可以通过使用安全表达式来直接定义服务的安全限制。

services:
    AppServiceAdminService:
        // ... other configurations ...
        arguments:
            - '@security.authorization_checker'

然后，在服务类中，你可以调用。isGranted在执行敏感操作之前，检查用户是否有适当的权限的方法。

use SymfonyComponentSecurityCoreAuthorizationAuthorizationCheckerInterface;

class AdminService {
    private $authorizationChecker;

    public function __construct(AuthorizationCheckerInterface $authorizationChecker) {
        $this->authorizationChecker = $authorizationChecker;
    }

    public function sensitiveAction() {
        if (!$this->authorizationChecker->isGranted('ROLE_ADMIN')) {
            throw new Exception('Access Denied.');
        }

        // Perform sensitive action
    }
}

因此，Symfony 的强大安全系统结合了投票者和访问控制规则，为开发者提供了实施有效且细致的访问管理所需的工具。

最后的话

基于这个基础，你应该现在能够应对Symfony中的简单和复杂的授权方案。记住最佳的安全实践包括配置良好的系统和谨慎的编码习惯。始终进行定期的安全审计，并且在彻底测试后不要假设您的系统是安全的！

长工码奴1523

长工码奴1523

在 Symfony 中实现授权功能是一项重要的任务，这不仅有助于保护应用的安全性，还能提升用户体验。以下是一些基本的步骤和建议：

1. 安装并配置 security.yml 文件

首先，你需要创建一个 security.yml 文件来定义身份验证和授权策略。

# security.yml
security:
    # ...
    providers:
        - class: AppSecurityCustomUserProvider
          options:
              email_field: 'email'
              password_field: 'password'

    firewalls:
        - id: default
          pattern: ^/
          form_login:
              login_path: /login
              check_path: /login_check
          logout:
              path:   /logout
              target: /
          anonymous: ~

        - id: auth
          pattern: ^/api/auth
          form_login:
              login_path: /login
              check_path: /login_check
          logout:
              path:   /logout
              target: /
          anonymous: false

    access_control:
        - { path: ^/api, roles: IS_AUTHENTICATED_ANONYMOUSLY }

2. 创建自定义用户提供商

在 Symfony 中，你可以使用 AppSecurityCustomUserProvider 来实现自定义用户验证策略。这个类会处理用户的登录和认证过程，并将数据存储到数据库或其他持久化存储中。

<?php

namespace AppSecurity;

use SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentSecurityCoreUserUserProviderInterface;
use SymfonyComponentSecurityCoreExceptionUsernameNotFoundException;
use SymfonyComponentSecurityCoreExceptionBadCredentialsException;

class CustomUserProvider implements UserProviderInterface
{
    public function loadUserByUsername($username)
    {
        // 在这里实现逻辑，例如检查用户名是否存在，密码是否正确等。
        // 这里假设有一个方法可以获取用户信息。
        $userRepository = new UserRepository();
        $user = $userRepository->findByEmail($username);

        if (!$user) {
            throw new UsernameNotFoundException('User not found');
        }

        return $user;
    }

    public function supportsClass($class)
    {
        return $class === AppEntityUser::class;
    }
}

3. 实现身份验证与授权规则

接下来，需要根据业务需求设置身份验证和授权规则。这通常涉及到设置路由权限和控制访问。

# routes.yaml
router:
    resources:
        - :api
        - :auth

在这些路由上，可以根据需要添加不同的权限控制。

# api.yaml
api:
    security:
        access_control:
            - { path: ^/api/auth, roles: IS_AUTHENTICATED_ANONYMOUSLY }

4. 使用 @SecurityGuard 注解

为了确保用户通过了安全验证，可以在控制器中添加 @SecurityGuard 注解来触发安全检查。

<?php

namespace AppController;

use SymfonyBundleFrameworkBundleControllerAbstractController;
use SymfonyComponentHttpFoundationResponse;
use SymfonyComponentRoutingAnnotationRoute;

class AuthController extends AbstractController
{
    /**
     * @Route("/api/auth", name="api_auth")
     */
    public function authenticate(): Response
    {
        // 检查用户是否已登录
        if ($this->isGranted("IS_AUTHENTICATED_ANONYMOUSLY")) {
            return new Response("You are already authenticated as an anonymous user.");
        } else {
            // 如果不是匿名用户，则跳转至登录页面
            return $this->redirectToRoute("app_login");
        }
    }
}

示例代码

以下是一个简单的示例代码片段，展示了如何在 Symfony 应用程序中使用自定义用户验证策略：

<?php

namespace AppSecurity;

use SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentSecurityCoreUserUserProviderInterface;
use SymfonyComponentSecurityCoreExceptionUsernameNotFoundException;
use SymfonyComponentSecurityCoreExceptionBadCredentialsException;

class CustomUserProvider implements UserProviderInterface
{
    private $userRepository;

    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function loadUserByUsername($username)
    {
        $user = $this->userRepository->findOneBy(['email' => $username]);

        if (!$user) {
            throw new UsernameNotFoundException('User not found');
        }

        return $user;
    }

    public function supportsClass($class)
    {
        return $class === AppEntityUser::class;
    }
}

总结

通过以上步骤，你可以为 Symfony 应用程序中的资源提供身份验证和授权服务。注意，实际应用中还需要考虑更复杂的情况，如缓存机制、用户管理、错误处理等。希望这能帮助你在 Symfony 开发过程中实现有效的身份验证和授权解决方案。

最新更新