V skutočnosti je to sofistikovaný autorizačný rámec schopný zvládnuť zložité štátne stroje, hierarchické povolenia a tok autentifikácie bez štátu. Táto príručka skúma 10 pokročilých vzorov pomocou Symfony 7.4. Bezdrôtová autentifikácia API s autentifikáciouEntryPointInterface Vzhľadom k tomu, Symfony 6.2+, AuthenticationEntryPointInterface je preferovaný spôsob, ako zaobchádzať s API tokeny (JWT, Opaque, atď.) bez overhead staré Guard autentizátory. Musíte zabezpečiť cesty pod Použitie A token, overovanie proti databáze alebo externej službe, úplne obchádzanie relácií. 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: Vykonajte žiadosť o cURL. Mali by ste dostať 401 bez hlavičky a 200 s ním. curl -I -H "Authorization: Bearer YOUR_VALID_TOKEN" http://localhost:8080/api/profile
 Autentifikácia bez hesla „Magic Link“ Pre jednoduché použitie, možno budete chcieť povoliť používateľom prihlásiť kliknutím na odkaz odoslaný do ich e-mailu, obchádzanie hesiel úplne. Konfigurácia autentizátora: Povoliť natívny autentizátor login_link.             login_link:
                check_route: login_check
                signature_properties: ['id', 'email']
                lifetime: 600
 Vytvoriť a odoslať odkaz: Vo vašom ovládači: 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: Pošlite formulár. Skontrolujte svoju poštovú dopravu (napr. Messenger alebo lokálne denníky). Kliknite na vytvorený odkaz. Mali by ste byť okamžite overení. Dynamická hierarchia úloh z databázy Štandardné symfonické úlohy sú definované staticky v Podnikové aplikácie často vyžadujú dynamické úlohy konfigurovateľné prostredníctvom rozhrania Admin UI. security.yaml Vyzdobíme si a servisu. 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: Zadajte zvykovú úlohu pre používateľa v DB. zabezpečiť Dedičstvo v tabuľke databázy. Prihláste sa a odložte Mali by ste vidieť, že zdedené role sa zobrazia automaticky. ROLE_SUPER_MANAGER ROLE_SUPER_MANAGER ROLE_ADMIN $user->getRoles() Komplexná obchodná logika s voličmi a atribútmi Nevkladajte autorizačnú logiku do ovládačov. Používajte hlasovateľov. V Symfónii 7.4 môžeme kombinovať s konkrétnymi témami a atribútmi pre čistý kód. #[IsGranted] Používateľ môže upraviť príspevok iba vtedy, ak je autorom alebo editorom a príspevok je „Publikovaný“ (ale nie návrh). 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: Skúste sa dostať na cestu úprav ako non-autor na príspevku Návrh. . 403 Access Denied Rýchlosť obmedzenia pokusov o login Symfony integruje RateLimiter priamo do firewallu. Configure Rate Limiter: # config/packages/security.yaml
security:
    firewalls:
        main:
            login_throttling:
                max_attempts: 3
 Verification: Skúste sa prihlásiť s nesprávnym heslom 4 krát v rýchlom poradí. chyba, ktorá zabraňuje tomu, aby kontrola dokonca zasiahla databázu. 429 Too Many Requests Programové prihlásenie (automatické prihlásenie po registrácii) Po tom, čo sa používateľ zaregistruje, nútenie ich znova zadať svoje heslo je zlé UX. Môžete sa prihlásiť programaticky pomocou bezpečnostného pomocníka. 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: Všimnite si, že ste okamžite presmerovaní na ovládací panel a profil vás zobrazí ako overený. Blokovanie pozastavených používateľov (User Checkers) Ak používateľa v databáze zakážete, môže byť stále prihlásený, ak je jeho relácia aktívna. Prebieha na každej žiadosti o aktívne relácie. 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 automaticky označuje implementované triedy Musíte ho však explicitne prepojiť s firewallom. UserCheckerInterface security:
    firewalls:
        main:
            lazy: true
            provider: app_user_provider
            user_checker: App\Security\UserEnabledChecker
 Verification: Prihláste sa ako platný používateľ. manuálne zmeniť Vlajka 2 v databáze. Obnoviť stránku. Mali by ste byť okamžite odhlásený a presmerovaný na prihlasovaciu stránku s chybovou správou. is_suspended true Impersonácia (používateľ prepínača) Umožnite administrátorom „stať sa“ inými používateľmi na riešenie problémov. Configuration: security:
    firewalls:
        main:
            switch_user: true 
    
    role_hierarchy:
        ROLE_ADMIN: [ROLE_ALLOWED_TO_SWITCH]
 Restrict Target Users (Optional but Recommended): Zvyčajne nechcete, aby admin predstieral 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: Ako admin na návštevu? Na paneli s nástrojmi by sa malo zobraziť „Impersonating“. Navštívte ?_switch_user=_exit na návrat. _switch_user=someuser@example.com súhrnné informácie _switch_user=someuser@example.com súhrnné informácie Komplexná kontrola prístupu s výrazmi Niekedy ROLE_ADMIN nestačí v access_control. Potrebujete logiku ako „Admins from IP 10.0.0.1“ alebo „Užívatelia s konkrétnym hlavičkou“. 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: Skúste prístup z inej IP adresy (alebo vysmievať sa IP v teste). mala by odmietnuť prístup, aj keď máte . /admin/sensitive ROLE_ADMIN Bezpečnostný audit Logovanie prostredníctvom udalostí Bezpečnosť je neúplná bez pozorovateľnosti. Mali by ste zaznamenávať úspešné prihlásenia, zlyhania a prístupové udalosti. 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: Tail svoj log súbor (tail -f var/log/dev.log) a vykonať prihlásenie. Uvidíte štruktúrovaný záznam log JSON pre udalosť overenia. záver Symfony Security komponent už dlho drží povesť jedného z najzložitejších častí rámca. Avšak, ako sme preskúmali v týchto desiatich vzoroch, táto zložitosť sa priamo prekladá do granulárnej kontroly a flexibility na úrovni podniku. V Symfony 7.4 sa bezpečnosť už netýka len zabránenia neoprávnenému prístupu k adresám URL. Je to o vytváraní bezproblémových používateľských skúseností – či už prostredníctvom Magic Links, ktoré znižujú trenie, Impersonation, ktorý posilňuje podporné tímy, alebo Limiters, ktoré ticho chránia vašu infraštruktúru. Presunutím sa nad rámec štandardného form_login a prijímaním nástrojov, ako sú Voters, Custom UserCheckers, presuniete bezpečnostnú logiku zo svojich ovládačov a do špecializovaných, testovateľných tried. To nasleduje základnú filozofiu moderného vývoja PHP: oddeľovanie. Vaše ovládače zostávajú tenké, vaša obchodná logika zostáva čistá a vaše bezpečnostné politiky sa stávajú opakovateľnými aktívami namiesto tvrdo kódovaných podmienených kontrol. Keď implementujete tieto vzory, nezabudnite, že zabezpečenie nie je funkcia, ktorú pridáte na konci; je to architektonický štandard, ktorý ste pripravili od začiatku. Môžete nájsť úplnú implementáciu a sledovať pokrok projektu na GitHub: [ ] Source Code: https://github.com/mattleads/SecurityPatterns https://github.com/mattleads/SecurityPatterns Let’s Connect! Ak ste to našli užitočné alebo máte otázky týkajúce sa implementácie, rád by som počul od vás. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Spoločnosť Google (Twitter): [https://x.com/MattLeads] Hľadať hotely: [https://t.me/MattLeads] Spoločnosť 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

Tento zvuk je vyrobený v pôvodnom jazyku príbehu!

10 techník v symfónii, ktoré vám pomôžu zabezpečiť ako profesionál

About Author

KOMENTÁRE

ZAVISTE ŠTÍTKY

TENTO ČLÁNOK BOL PREDSTAVENÝ V

Related Stories

Mutmut: a Python mutation testing system

16 Best Sklearn Datasets for Building Machine Learning Models

112 Stories To Learn About Hackernoon Community

Behavior of a shapely Spider

Mutmut: a Python mutation testing system

16 Best Sklearn Datasets for Building Machine Learning Models

112 Stories To Learn About Hackernoon Community

Behavior of a shapely Spider

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps