Il componente Symfony Security è spesso sottovalutato, trattato semplicemente come una “porta di accesso”.In realtà, è un sofisticato framework di autorizzazione in grado di gestire macchine di stato complesse, autorizzazioni gerarchiche e flusso di autenticazione senza stato. Questa guida esplora 10 modelli avanzati utilizzando Symfony 7.4. Autenticazione Stateless API con AuthenticationEntryPointInterface Le applicazioni moderne spesso richiedono un'API senza stato insieme a un frontend statico. Dal momento che Symfony 6.2+, l'AuthenticationEntryPointInterface è il modo preferito per gestire i token API (JWT, Opaque, ecc.) senza il sovraccarico dei vecchi autenticatori Guard. Bisogna garantire la sicurezza delle strade Utilizzando a Token, verificandolo contro un database o un servizio esterno, completamente bypassando le sessioni. 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: Eseguire una richiesta cURL. Dovresti ricevere un 401 senza l'intestazione e 200 con esso. curl -I -H "Authorization: Bearer YOUR_VALID_TOKEN" http://localhost:8080/api/profile
 Autenticazione senza password “Magic Link” Per facilità d'uso, potresti voler consentire agli utenti di accedere facendo clic su un link inviato alla loro e-mail, eludendo completamente le password. Configurare l'autenticatore: attivare l'autenticatore nativo login_link.             login_link:
                check_route: login_check
                signature_properties: ['id', 'email']
                lifetime: 600
 Generare e inviare il link: nel tuo controller: 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: Invia il modulo. Controlla il tuo trasporto di posta elettronica (ad esempio, messenger o log locali). Fai clic sul link generato. Devi essere immediatamente autenticato. Hierarchia dei ruoli dinamici da un database I ruoli Symfony standard sono definiti in modo statico in Le applicazioni aziendali richiedono spesso ruoli dinamici configurabili tramite un'interfaccia utente di amministrazione. security.yaml Decoriamo il Il Servizio. 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: Assegnare un ruolo abituale a un utente nel DB. Assicurarsi eredità nella tua tabella di database. Accedi e scarica Dovresti vedere che i ruoli ereditati appaiono automaticamente. ROLE_SUPER_MANAGER ROLE_SUPER_MANAGER ROLE_ADMIN $user->getRoles() Logica aziendale complessa con elettori e attributi Non impostare la logica di autorizzazione nei controller. Utilizzare Voters. In Symfony 7.4, possiamo combinare con argomenti e attributi specifici per il codice pulito. #[IsGranted] Un utente può modificare un post solo se è l'autore O se è un editor e il post è "Pubblicato" (ma non progetto). 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: Prova ad accedere al percorso di modifica come non autore su un post di progetto. . 403 Access Denied Limitare i tentativi di login La protezione della forza bruta è fondamentale. Symfony integra RateLimiter direttamente nel firewall. Configure Rate Limiter: # config/packages/security.yaml
security:
    firewalls:
        main:
            login_throttling:
                max_attempts: 3
 Verification: tentativo di accedere con la password sbagliata 4 volte in rapida successione. il 4° tentativo errore, impedendo al controllo di colpire anche il database. 429 Too Many Requests Login automatico (Login automatico dopo la registrazione) Dopo che un utente si registra, costringerli a digitare nuovamente la password è un uso sbagliato. 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: Nota che sei immediatamente reindirizzato al dashboard e il profilo ti mostra come autenticato. Blocco degli utenti sospesi (User Checkers) Se si blocca un utente nel database, potrebbe essere ancora connesso se la sessione è attiva. eseguire su ogni richiesta di sessioni attive. 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 etichetta automaticamente le classi che implementano Tuttavia, è necessario collegarlo esplicitamente nel firewall. UserCheckerInterface security:
    firewalls:
        main:
            lazy: true
            provider: app_user_provider
            user_checker: App\Security\UserEnabledChecker
 Verification: Accedi come utente valido. Cambiare manualmente La bandiera è Rifresca la pagina. Devi essere immediatamente disconnesso e reindirizzato alla pagina di accesso con il messaggio di errore. is_suspended true Impersonazione degli utenti (Switch User) Consenti agli amministratori di "diventare" altri utenti per il debug dei problemi. Configuration: security:
    firewalls:
        main:
            switch_user: true 
    
    role_hierarchy:
        ROLE_ADMIN: [ROLE_ALLOWED_TO_SWITCH]
 Restrict Target Users (Optional but Recommended): Di solito non vuoi che un amministratore finta di essere un super amministratore. . 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: Come un amministratore, visita? La barra degli strumenti dovrebbe mostrare “Impersonating”. Visita ?_switch_user=_exit per tornare. _switch_user=someuser@example.com _switch_user=someuser@esempio.it Controllo di accesso complesso con espressioni A volte, ROLE_ADMIN non è sufficiente in access_control. Hai bisogno di logica come “Admins from IP 10.0.0.1” o “Users with a specific header”. 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: Prova ad accedere da un'altra IP (o scherzare con l'IP in un test). dovrebbe negare l'accesso anche se hai . /admin/sensitive ROLE_ADMIN Monitoraggio della sicurezza tramite eventi La sicurezza è incompleta senza osservabilità. dovresti registrare login di successo, fallimenti e eventi di accesso rifiutati. 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: Inserisci il tuo file di log (tail -f var/log/dev.log) e esegui un login. Vedrai l'entrata di log JSON strutturata per l'evento di autenticazione. Conclusione Il componente Symfony Security ha da tempo la reputazione di essere una delle parti più complesse del framework.Tuttavia, come abbiamo esplorato in questi dieci modelli, questa complessità si traduce direttamente in controllo granulare e flessibilità di livello aziendale. In Symfony 7.4, la sicurezza non riguarda più solo la prevenzione dell'accesso non autorizzato a un URL. Si tratta di creare esperienze utente senza problemi, sia attraverso i collegamenti magici che riducono l'attrito, l'impersonazione che autorizza i team di supporto o i limitatori di tariffa che proteggono silenziosamente la tua infrastruttura. Passando al di là della form_login standard e adottando strumenti come Voters, UserCheckers personalizzati, si sposta la logica di sicurezza dai controller e in classi dedicate, testabili. Questo segue la filosofia di base dello sviluppo PHP moderno: disconnettersi. I controller rimangono sottili, la logica aziendale rimane pura, e le politiche di sicurezza diventano asset riutilizzabili piuttosto che controlli condizionali rigorosamente codificati. Mentre si implementano questi modelli, ricordare che la sicurezza non è una caratteristica che si aggiunge alla fine; è uno standard architettonico che si prepara fin dall'inizio. Puoi trovare l'implementazione completa e seguire il progresso del progetto su GitHub: [ ] Source Code: https://github.com/mattleads/SecurityPatterns https://github.com/mattleads/SecurityPatterns Let’s Connect! Se hai trovato questo utile o hai domande sull'implementazione, mi piacerebbe sentire da te. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Sito web: [https://x.com/MattLeads] Sito ufficiale: [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

Questo audio è prodotto nella lingua originale della storia!

10 tecniche in Symfony che ti aiuteranno a proteggere come un professionista

About Author

COMMENTI

CARTELLINI

QUESTO ARTICOLO È STATO PRESENTATO IN

Related Stories

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

Meet Dealscard, Winner of Startups of The Year 2024 in Ghaziabad/Deal Aggregator

I Built an AI Copilot That Thinks in Exploits, Not Prompts

Arron Goolsbey Talks Future of Gaming with AI and Blockchain at Mythical Games

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

Meet Dealscard, Winner of Startups of The Year 2024 in Ghaziabad/Deal Aggregator

I Built an AI Copilot That Thinks in Exploits, Not Prompts

Arron Goolsbey Talks Future of Gaming with AI and Blockchain at Mythical Games

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps