Komponent Symfony Security jest często niedoceniany, traktowany jedynie jako „brama logowania”.W rzeczywistości jest to wyrafinowane ramy autoryzacji zdolne do obsługi złożonych maszyn stanowych, uprawnień hierarchicznych i przepływu uwierzytelniania bez państwa. Ten przewodnik analizuje 10 zaawansowanych wzorców przy użyciu Symfony 7.4. Bezprzewodowe uwierzytelnianie API z uwierzytelnieniemEntryPointInterface Ponieważ Symfony 6.2+, AuthenticationEntryPointInterface jest preferowanym sposobem obsługi tokenów API (JWT, Opaque itp.) bez konieczności korzystania ze starych uwierzytelniaczy Guard. Trzeba zabezpieczyć drogi Wykorzystując a token, weryfikując go przeciwko bazie danych lub usłudze zewnętrznej, całkowicie omijając sesje. Scenario: /api Bearer Create the Authenticator: namespace App\Security;

use App\Repository\ApiTokenRepository;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\Exception\CustomUserMessageAuthenticationException;
use Symfony\Component\Security\Http\Authenticator\AbstractAuthenticator;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\SelfValidatingPassport;

use Symfony\Component\Security\Http\EntryPoint\AuthenticationEntryPointInterface;

class ApiTokenAuthenticator extends AbstractAuthenticator implements AuthenticationEntryPointInterface
{
    public function __construct(private readonly ApiTokenRepository $apiTokenRepository)
    {
    }

    public function supports(Request $request): ?bool
    {
        return $request->headers->has('Authorization') && str_starts_with($request->headers->get('Authorization'), 'Bearer ');
    }

    public function authenticate(Request $request): Passport
    {
        $apiToken = substr($request->headers->get('Authorization'), 7);
        if (null === $apiToken) {
            throw new CustomUserMessageAuthenticationException('No API token provided');
        }

        $token = $this->apiTokenRepository->findOneBy(['token' => $apiToken]);
        if (null === $token || !$token->isValid()) {
            throw new CustomUserMessageAuthenticationException('Invalid API Token');
        }

        return new SelfValidatingPassport(new UserBadge($token->getOwner()->getUserIdentifier()));
    }

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
        return null;
    }

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        $data = ['message' => strtr($exception->getMessageKey(), $exception->getMessageData())];

        return new JsonResponse($data, Response::HTTP_UNAUTHORIZED);
    }

    public function start(Request $request, AuthenticationException $authException = null): Response
    {
        return new JsonResponse(['message' => 'Authentication Required'], Response::HTTP_UNAUTHORIZED);
    }
}
 Configure security.yaml:         api:
            pattern: ^/api
            stateless: true
            custom_authenticators:
                - App\Security\ApiTokenAuthenticator
            entry_point: App\Security\ApiTokenAuthenticator
 Verification: Powinieneś otrzymać 401 bez nagłówka i 200 z nim. curl -I -H "Authorization: Bearer YOUR_VALID_TOKEN" http://localhost:8080/api/profile
 Autoryzacja bez hasła „Magic Link” Aby ułatwić korzystanie, możesz pozwolić użytkownikom na zalogowanie się, klikając link wysłany do ich poczty e-mail, całkowicie omijając hasła. Konfiguracja Authenticator: Włącz native login_link authenticator.             login_link:
                check_route: login_check
                signature_properties: ['id', 'email']
                lifetime: 600
 Generuj i wysyłaj link: W kontrolerze: namespace App\Controller;

use App\Repository\UserRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Notifier\NotifierInterface;
use Symfony\Component\Notifier\Recipient\Recipient;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
use Symfony\Component\Security\Http\LoginLink\LoginLinkHandlerInterface;
use Symfony\Component\Security\Http\LoginLink\LoginLinkNotification;

class SecurityController extends AbstractController
{

    #[Route('/login/link', name: 'login_link_start', methods: ['GET', 'POST'])]
    public function requestLink(
        Request $request,
        LoginLinkHandlerInterface $loginLinkHandler,
        NotifierInterface $notifier,
        UserRepository $userRepository
    ): Response {
        if ($request->isMethod('POST')) {
            $email = $request->request->get('email');
            $user = $userRepository->findOneBy(['email' => $email]);

            if ($user) {
                $loginLinkDetails = $loginLinkHandler->createLoginLink($user);

                $notification = (new LoginLinkNotification(
                    $loginLinkDetails,
                    'Welcome back! Click to login.'
                ));
                $notifier->send($notification, new Recipient($user->getEmail()));

                // For demonstration, we'll dump the link to the profiler instead of sending an email.
                // In a real app, you'd remove this.
                $this->addFlash('success', 'Login link sent! Check the profiler for the link.');
                $this->addFlash('login_link', $loginLinkDetails->getUrl());
            }

            return $this->render('security/link_sent.html.twig');
        }

        return $this->render('security/request_login_link.html.twig');
    }

    #[Route('/login/check', name: 'login_check')]
    public function check(): void
    {
        throw new \LogicException('This controller should not be reached!');
    }
}
 Verification: Wyślij formularz. Sprawdź transport mailer (np. dzienniki messenger lub lokalne). Kliknij wygenerowany link. Dynamiczna hierarchia ról z bazy danych Standardowe role symfonii są zdefiniowane statycznie w Aplikacje przedsiębiorstwa często wymagają dynamicznych ról konfigurowalnych za pośrednictwem interfejsu użytkownika administracyjnego. security.yaml Dekorujemy je w służbie. security.role_hierarchy Create the Decorator namespace App\Security;

use App\Repository\RoleRepository;
use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
use Symfony\Component\Security\Core\Role\RoleHierarchy;
use Symfony\Component\Security\Core\Role\RoleHierarchyInterface;

#[AsDecorator('security.role_hierarchy')]
class DatabaseRoleHierarchy implements RoleHierarchyInterface
{
    private RoleHierarchyInterface $mergedHierarchy;

    public function __construct(
        // The decorated service is not used, but is required for the decorator pattern
        RoleHierarchyInterface $inner, 
        array $staticHierarchy,
        private readonly RoleRepository $roleRepository
    ) {
        $dbHierarchy = $this->roleRepository->findAllHierarchy();

        // array_merge_recursive can have unexpected results with numeric keys, but it's fine for role strings.
        $merged = array_merge_recursive($staticHierarchy, $dbHierarchy);

        $this->mergedHierarchy = new RoleHierarchy($merged);
    }

    public function getReachableRoleNames(array $roles): array
    {
        return $this->mergedHierarchy->getReachableRoleNames($roles);
    }
}
 Verification: Przydziel zwyczajową rolę do użytkownika w DB. upewnij się Spadkobiercy w tabeli bazy danych. log in i dump Powinieneś zobaczyć, że odziedziczone role pojawiają się automatycznie. ROLE_SUPER_MANAGER ROLE_SUPER_MANAGER ROLE_ADMIN $user->getRoles() Kompleksowa logika biznesowa z wyborcami i atrybutami Nie wkładaj logiki autoryzacji do kontrolerów. Użyj wyborców. W Symfonii 7.4 możemy łączyć z konkretnymi tematami i atrybutami czystego kodu. #[IsGranted] Użytkownik może edytować post tylko wtedy, gdy jest autorem lub jest redaktorem, a post jest „opublikowany” (ale nie projekt). The Voter: namespace App\Security\Voter;

use App\Entity\Post;
use App\Entity\User;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Voter;

class PostVoter extends Voter
{
    public const string EDIT = 'POST_EDIT';

    protected function supports(string $attribute, mixed $subject): bool
    {
        return $attribute === self::EDIT && $subject instanceof Post;
    }

    protected function voteOnAttribute(string $attribute, mixed $subject, TokenInterface $token): bool
    {
        $user = $token->getUser();
        if (!$user instanceof User) {
            return false;
        }

        /** @var Post $post */
        $post = $subject;

        // Rule 1: Author can always edit
        if ($post->getAuthor() === $user) {
            return true;
        }

        // Rule 2: Editors can only edit if Published
        if (in_array('ROLE_EDITOR', $user->getRoles()) && $post->isPublished()) {
            return true;
        }

        return false;
    }
}
 The Controller: namespace App\Controller;

use App\Entity\Post;
use App\Security\Voter\PostVoter;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;

class PostController extends AbstractController
{
    #[Route('/post/{id}/edit', name: 'post_edit')]
    #[IsGranted(PostVoter::EDIT, subject: 'post')]
    public function edit(Post $post): Response
    {
        return $this->render('post/edit.html.twig', [
            'post' => $post,
        ]);
    }
}
 Verification: Spróbuj uzyskać dostęp do ścieżki edycji jako nieautor na wpisie projektu. . 403 Access Denied Ograniczenie prób logowania Symfony integruje RateLimiter bezpośrednio w zaporę. Configure Rate Limiter: # config/packages/security.yaml
security:
    firewalls:
        main:
            login_throttling:
                max_attempts: 3
 Verification: Spróbuj zalogować się z błędnym hasłem 4 razy z rzędu. błąd, uniemożliwiający sprawdzenie nawet uderzenia w bazę danych. 429 Too Many Requests Logowanie programowe (automatyczne logowanie po rejestracji) Po zarejestrowaniu się użytkownika, zmuszanie go do ponownego wpisywania hasła jest złe UX. namespace App\Controller;

use App\Entity\User;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Attribute\Route;

class RegistrationController extends AbstractController
{
    #[Route('/register', name: 'app_register', methods: ['GET', 'POST'])]
    public function register(
        Request $request,
        UserPasswordHasherInterface $passwordHasher,
        EntityManagerInterface $entityManager,
        Security $security
    ): Response
    {
        if ($request->isMethod('POST')) {
            $email = $request->request->get('email');
            $password = $request->request->get('password');

            $user = new User();
            $user->setEmail($email);
            $user->setPassword($passwordHasher->hashPassword($user, $password));

            $entityManager->persist($user);
            $entityManager->flush();

            return $security->login($user,'security.authenticator.form_login.main');
        }

        return $this->render('registration/register.html.twig');
    }
}
 Verification: Zarejestruj nowego użytkownika za pośrednictwem formularza.Zauważ, że natychmiast zostaniesz przekierowany do pulpitu i profil pokaże Cię jako uwierzytelnionego. Blokowanie zawieszonych użytkowników (User Checkers) Jeśli wyłączysz użytkownika z bazy danych, może on nadal być zalogowany, jeśli jego sesja jest aktywna. Uruchamia się na każdym żądaniu aktywnych sesji. UserChecker namespace App\Security;

use App\Entity\User;
use Symfony\Component\Security\Core\Exception\CustomUserMessageAccountStatusException;
use Symfony\Component\Security\Core\User\UserCheckerInterface;
use Symfony\Component\Security\Core\User\UserInterface;

class UserEnabledChecker implements UserCheckerInterface
{
    public function checkPreAuth(UserInterface $user): void
    {
        if (!$user instanceof User) {
            return;
        }

        if ($user->isDeleted()) {
            throw new CustomUserMessageAccountStatusException('Your account has been deleted.');
        }
    }

    public function checkPostAuth(UserInterface $user): void
    {
        if (!$user instanceof User) {
            return;
        }

        if ($user->isSuspended()) {
            throw new CustomUserMessageAccountStatusException('Your account is suspended.');
        }
    }
}
 Configuration: Symfony automatycznie znaczniki klasy wdrażania Jednak musisz wyraźnie łączyć go w zaporze. UserCheckerInterface security:
    firewalls:
        main:
            lazy: true
            provider: app_user_provider
            user_checker: App\Security\UserEnabledChecker
 Verification: Zaloguj się jako ważny użytkownik. ręczna zmiana Flaga to Odśwież stronę. Należy natychmiast wylogować się i przekierować na stronę logowania z komunikatem o błędzie. is_suspended true Impersonacja użytkownika (Switch User) Pozwól administratorom „stać się” innymi użytkownikami w celu usuwania problemów. Configuration: security:
    firewalls:
        main:
            switch_user: true 
    
    role_hierarchy:
        ROLE_ADMIN: [ROLE_ALLOWED_TO_SWITCH]
 Restrict Target Users (Optional but Recommended): Zazwyczaj nie chcesz, aby administrator udawał Super Admin. . Event Listener namespace App\EventListener;

use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Security\Http\Event\SwitchUserEvent;

#[AsEventListener(event: SwitchUserEvent::class, method: 'onSwitchUser')]
class SwitchUserListener
{
    public function onSwitchUser(SwitchUserEvent $event): void
    {
        $targetUser = $event->getTargetUser();

        if ($targetUser !== null && in_array('ROLE_SUPER_ADMIN', $targetUser->getRoles())) {
            throw new AccessDeniedException('Cannot impersonate Super Admins.');
        }
    }
}
 Verification: Jako admin odwiedź nas. Pasek narzędzi powinien wyświetlać „Impersonating”. Odwiedź ?_switch_user=_exit, aby wrócić. _switch_user=someuser@example.com _switch_user=niektórzy użytkownicy@example.com Kompleksowa kontrola dostępu z wyrazami Czasami ROLE_ADMIN nie wystarcza w access_control. Potrzebujesz logiki, takiej jak „Admins from IP 10.0.0.1” lub „Użytkownicy z określonym nagłówkiem”. security: 
    access_control:
        - { path: ^/api, roles: ROLE_USER }
        - { path: ^/admin/sensitive, allow_if: "is_granted('ROLE_ADMIN') and request.getClientIp() in ['127.0.0.1', '::1']" }
 Verification: Spróbuj dostępu z innego adresu IP (lub żartować z IP w teście). powinno odmówić dostępu, nawet jeśli masz . /admin/sensitive ROLE_ADMIN Audyt bezpieczeństwa Logowanie poprzez wydarzenia Bezpieczeństwo jest niekompletne bez możliwości obserwacji. Powinieneś rejestrować udane logowania, niepowodzenia i odrzucony dostęp do zdarzeń. namespace App\EventSubscriber;

use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Security\Http\Event\InteractiveLoginEvent;
use Symfony\Component\Security\Http\Event\LoginFailureEvent;
use Symfony\Component\Security\Http\SecurityEvents;

readonly class SecurityAuditSubscriber implements EventSubscriberInterface
{
    public function __construct(private LoggerInterface $securityLogger) {}

    public static function getSubscribedEvents(): array
    {
        return [
            SecurityEvents::INTERACTIVE_LOGIN => 'onLoginSuccess',
            LoginFailureEvent::class => 'onLoginFailure',
        ];
    }

    public function onLoginSuccess(InteractiveLoginEvent $event): void
    {
        $user = $event->getAuthenticationToken()->getUser();
        $this->securityLogger->info('User Login Success', [
            'username' => $user->getUserIdentifier(),
            'ip' => $event->getRequest()->getClientIp(),
        ]);
    }

    public function onLoginFailure(LoginFailureEvent $event): void
    {
        $this->securityLogger->warning('User Login Failure', [
            'ip' => $event->getRequest()->getClientIp(),
            'error' => $event->getException()->getMessage(),
            'passport' => $event->getPassport()?->getUser()->getUserIdentifier(),
        ]);
    }
}
 Verification: Załóż plik dziennika (tail -f var/log/dev.log) i zaloguj się. zobaczysz zorganizowany wpis dziennika JSON dla zdarzenia uwierzytelniania. konkluzji Komponent Symfony Security od dawna cieszy się reputacją jako jedna z najbardziej złożonych części ramki. Jednak, jak przeanalizowaliśmy w tych dziesięciu wzorcach, ta złożoność przekłada się bezpośrednio na granularną kontrolę i elastyczność na poziomie przedsiębiorstwa. W Symfony 7.4 bezpieczeństwo nie polega już tylko na zapobieganiu nieautoryzowanemu dostępowi do adresu URL. Chodzi o tworzenie bezproblemowych doświadczeń użytkowników – czy to za pośrednictwem Magic Links, które zmniejszają tarcie, Impersonation, które umożliwia zespołom wsparcia, czy Limiters, które cicho chronią infrastrukturę. Przenosząc się poza standardowe form_login i przyjmując narzędzia, takie jak Voters, niestandardowe UserCheckers, przechodzisz logikę bezpieczeństwa z kontrolerów i do dedykowanych, testowalnych klas. To podąża za podstawową filozofią nowoczesnego rozwoju PHP: odłączanie. Twoje kontrolery pozostają cienkie, twoja logika biznesowa pozostaje czysta, a twoje zasady bezpieczeństwa stają się zasobami wielokrotnego użytku, a nie twardo kodowanymi kontrolami warunkowymi. Gdy wdrażasz te wzorce, pamiętaj, że bezpieczeństwo nie jest funkcją, którą dodasz na końcu; jest to standard architektoniczny, który gotujesz od samego początku. Możesz znaleźć pełną implementację i śledzić postęp projektu na GitHub: [ ] Source Code: https://github.com/mattleads/SecurityPatterns https://github.com/mattleads/SecurityPatterns Let’s Connect! Jeśli znalazłeś to przydatne lub masz pytania dotyczące wdrożenia, chciałbym usłyszeć od ciebie. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Na stronie internetowej: [https://x.com/MattLeads] Wiadomości: [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Read My Stories

Ten dźwięk jest produkowany w oryginalnym języku historii!

10 technik w symfonii, które pomogą Ci zabezpieczyć się jak profesjonalista

About Author

UWAGI

ZAWIEŚĆ TAGI

ARTYKUŁ TEN ZOSTAŁ PREZENTOWANY W

Related Stories

Google's Gemini AI: A Thought Experiment in Deception

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

Pleasures of the telescope by Garrett Putman Serviss - Table of Links

Everything You Need to Know About HackerNoon’s Proof of Usefulness Hackathon

Google's Gemini AI: A Thought Experiment in Deception

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

Pleasures of the telescope by Garrett Putman Serviss - Table of Links

Everything You Need to Know About HackerNoon’s Proof of Usefulness Hackathon

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps