8. Autenticação e autorização
Duas perguntas distintas se colocam a cada requisição:
- Quem é o usuário? Isso é a autenticação: o usuário se identificou com um nome de usuário e uma senha, e cada requisição seguinte deve provar que vem dele;
- Ele tem permissão para acessar esta página? Isso é a autorização: no estudo de caso, somente um usuário com o papel ADMIN gerencia médicos e clientes.
A prova de identidade deve acompanhar cada requisição. O [Symfony] normalmente armazena o usuário logado em sua sessão (veja a seção sobre escopos), que é a solução mais simples para uma aplicação web. O estudo de caso, em todas as suas versões ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask], [Laravel]), usa, em vez disso, um token (JWT, JSON Web Token), que usaremos aqui: após o login, o servidor gera um token contendo a identidade do usuário e o assina com uma chave secreta (é o princípio do cookie assinado do Exemplo 23). O token é armazenado em um cookie; o navegador o reenvia a cada requisição; o servidor verifica a assinatura. O usuário pode ler seu token, mas não pode modificá-lo: qualquer modificação invalida a assinatura. O formato é padronizado (RFC 7519), entendido por todas as linguagens de programação, e o token inclui sua data de expiração. Acima de tudo, o servidor não precisa armazenar nada: qualquer servidor que conheça a chave pode verificar o token.
O [Symfony] tem um componente de segurança completo, integrado pelo SecurityBundle, cujos elementos usaremos como são:
- as URLs da aplicação são distribuídas entre firewalls (firewalls), cada um com seu próprio método de autenticação dos usuários;
- a autenticação é feita por authenticators (authenticators): objetos que determinam a identidade do usuário a cada requisição. O [Symfony] fornece vários deles (formulário de login, sessão, token de API etc.); escreveremos o nosso, que lê o token JWT. O restante da aplicação vê apenas o resultado: o usuário autenticado, fornecido por [#[CurrentUser]], [$this->getUser()] e, nas views, [app.user];
- os usuários são fornecidos por um user provider, e suas senhas recebem hash do PasswordHasher (algoritmo [bcrypt]);
- as autorizações são baseadas em papéis: a proteção de páginas é descrita por regras de controle de acesso ([access_control]) ou pelo atributo [#[IsGranted]] das ações; as views verificam um direito com [is_granted];
- As tentativas de login são limitadas pelo componente RateLimiter (Exemplo 27).
Tudo isso é feito por listeners de eventos do kernel (capítulo anterior): o firewall escuta [kernel.request] (prioridade 8), [#[IsGranted]] é lido em [kernel.controller_arguments], e as negações de acesso são exceções, tratadas em [kernel.exception].
A geração e a verificação de tokens ficam a cargo da biblioteca [firebase/php-jwt], a mais usada em [PHP], instalada pelo arquivo [composer.json] dos exemplos. (Existe um bundle muito usado para tokens, o JWT e [LexikJWTAuthenticationBundle], projetado para APIs; para uma aplicação web, bastam algumas linhas, que ilustram melhor o mecanismo.)
8.1. Exemplo 25: Login, token, página protegida
8.1.1. Configuração: .env, bundles.php e framework.yaml
O token é assinado com uma chave secreta, que não deve ser escrita diretamente no código. É hora de separar de verdade a configuração do código. As configurações específicas de uma instalação ficam no arquivo [.env] (Exemplo 01), que agora contém três novas linhas (um comentário, seguido de duas variáveis):
O padrão exige que o algoritmo usado (HMAC-SHA256) tenha uma chave de pelo menos 256 bits, ou 32 bytes; a biblioteca rejeita qualquer chave mais curta. O código em si não lê diretamente o arquivo [.env]: o componente [Dotenv] (exemplo 01) o converteu em variáveis de ambiente, que o contêiner fornece aos serviços que as solicitam (veremos isso com o serviço [AuthService]). Uma variável de ambiente real tem precedência sobre o arquivo [.env]: no [Linux] ou no [macOS], a aplicação seria iniciada com uma chave diferente da seguinte forma:
e no [Windows] (PowerShell):
(A opção [-d variables_order=EGPCS] instrui o [PHP] a preencher o array [$_ENV] com as variáveis de ambiente, o que sua configuração padrão nem sempre faz.) Em produção, os segredos costumam ser confiados ao [Symfony] vault (secrets vault, comando [bin/console secrets:set]), que os armazena criptografados dentro do projeto.
O SecurityBundle é adicionado à lista de bundles:
A sessão é usada aqui apenas para o token anti-CSRF do formulário de login (Exemplo 21):
8.1.2. Configuração de segurança: config/packages/security.yaml
- linhas 4–6: o algoritmo de hash de senhas para os usuários da classe [User]: [bcrypt]. (O valor [auto] selecionaria o melhor algoritmo disponível e seria capaz de verificar hashes de outros algoritmos);
- linhas 9–11: o user provider, o serviço que encontra um usuário a partir de seu ID (aqui, nossa classe [UsersService]). O [Symfony] fornece vários: [memory] (uma lista escrita neste arquivo), [entity] (uma tabela do banco de dados; veja o estudo de caso)...;
- Linhas 14–27: os firewalls. Cada um se aplica às URLs que correspondem ao seu padrão ([pattern]), sendo selecionado o primeiro que corresponder. O primeiro, [resources], cobre os arquivos do [Bootstrap] (Exemplo 15), sem segurança ([security: false]): não há necessidade de procurar um usuário para servir uma folha de estilo. O segundo, [main], não tem uma razão específica: cobre todas as demais URLs;
- linha 23: o firewall é stateless (stateless): o usuário autenticado não é armazenado na sessão; ele é identificado a cada requisição com base em seu token;
- Linhas 26–27: o authenticator do firewall, nossa classe [TokenAuthenticator];
- Linhas 31–32: o controle de acesso: uma lista de regras, examinadas em ordem, das quais se aplica a primeira que corresponder à URL. As URLs que começam por [/profile] exigem um usuário autenticado ([IS_AUTHENTICATED]); as demais são públicas.
Em um projeto padrão, este arquivo é escrito pelo [Symfony Flex] quando o bundle ([composer require security]) é instalado, e o comando [bin/console make:user] do [MakerBundle] escreve a classe do usuário e seu provider.
8.1.3. Usuários: src/Security/User.php e UsersService.php
- Linha 11: um usuário. O [Symfony] espera que os usuários autenticados implementem a interface [UserInterface]: seus métodos fornecem o identificador e os papéis do usuário. A interface [PasswordAuthenticatedUserInterface] acrescenta a senha com hash. Em uma aplicação típica, a entidade [Doctrine] da tabela de usuários (próximo capítulo) implementa esses métodos;
- Linhas 13–23: o login, o nome, o papel, o hash da senha e o conteúdo do token que autenticou o usuário (vazio para um usuário obtido da lista de usuários). Um servidor nunca armazena uma senha, nem mesmo criptografada: se o banco de dados fosse roubado, as senhas também seriam (e muitas pessoas usam a mesma senha em todos os lugares). Ele armazena o resultado de uma função de hash, uma função de mão única: é possível calcular o hash de uma senha, mas não é possível recuperar a senha a partir do hash. Para verificar uma senha digitada, calcula-se o hash dela e compara-se com o que está armazenado;
- linhas 32–35: os papéis, conforme definidos pelo [Symfony]: strings que começam com [ROLE_]. O papel [USER] do estudo de caso se torna [ROLE_USER].
- Linhas 17–20: dois usuários de teste, fixados no código (o exemplo 28 e o estudo de caso os armazenarão em um banco de dados): para cada login, o nome, o papel e o hash da senha. O hash é gerado com o algoritmo bcrypt, projetado para senhas. Ele tem duas características marcantes. É intencionalmente lento, com um nível de lentidão ajustável (o custo, aqui definido como 10: 2^10 ciclos de computação, o que resulta no hash [$10$]): algumas dezenas de milissegundos, imperceptíveis para um usuário, mas que tornam muito custoso para um invasor tentar bilhões de senhas. Ele usa salt: um salt gerado aleatoriamente é misturado à senha antes do hash e armazenado dentro do próprio hash (os 22 caracteres que seguem [$10$]); assim, dois usuários com a mesma senha terão hashes diferentes. Os hashes foram calculados uma única vez pela função [password_hash] do [PHP] (linha 16), ou pelo comando [bin/console security:hash-password] do [Symfony]: calculá-los a cada requisição seria uma perda de tempo desnecessária, já que a aplicação é reconstruída a cada requisição. O [bcrypt] considera apenas os primeiros 72 bytes de uma senha: o estudo de caso leva isso em conta;
- linhas 22–29: o usuário de um login, ou [null]. [isset] verifica a existência de uma chave; a atribuição [[$name, $role, $hash] = ...] desestrutura um array: cada variável recebe o elemento correspondente;
- linhas 32–47: os três métodos da interface [UserProviderInterface], que fazem da classe um provider de usuários: [loadUserByIdentifier] retorna o usuário associado a um identificador, ou lança a exceção [UserNotFoundException]; [refreshUser] recarrega o usuário armazenado na sessão (desnecessário com um firewall stateless); [supportsClass] especifica a classe dos usuários fornecidos. O operador [??] seguido de [throw] lança a exceção quando a expressão à esquerda é avaliada como [null].
8.1.4. O serviço de autenticação: src/Security/AuthService.php
- Linhas 17–26: o serviço recebe o provider de usuários, o serviço de hash de senhas ([UserPasswordHasherInterface], que aplica o algoritmo selecionado em [security.yaml]) e dois valores de configuração. O atributo [#[Autowire(env: 'NAME')]] fornece o valor de uma variável de ambiente; um prefixo a converte: [int:] para um inteiro (há outros: [bool:], [json:], [base64:]...). O tempo de vida é uma propriedade pública somente leitura: o controller a utilizará;
- linhas 31–41: verificação de um nome de usuário e de uma senha. [isPasswordValid] calcula o hash da senha digitada usando o salt do hash armazenado e compara os dois hashes. Um nome de usuário desconhecido e uma senha incorreta produzem o mesmo resultado, [null];
- Linhas 44–56: geração do token. O token contém um array de declarações (claims) sobre o usuário. Algumas têm nomes padronizados: [sub] (subject), o identificador do usuário; [iat] (issued at), a data de criação; [exp] (expiration), a data de expiração. As datas são expressas em segundos decorridos desde 1º de janeiro de 1970 (a função [time()] do [PHP]). Os demais campos são opcionais: aqui, o nome e o papel. [JWT::encode] gera o token e o assina usando o algoritmo [HS256] (HMAC-SHA256, uma assinatura com chave secreta compartilhada);
- linhas 60–69: verificação do token. [JWT::decode] verifica a assinatura e a data de expiração e, em seguida, retorna as declarações (um objeto, convertido em array por [(array)]). Qualquer anomalia (token forjado, expirado ou malformado) lança uma exceção; [catch (Throwable)] captura todas ([Throwable] é a interface de todas as exceções e erros do [PHP]; o nome da variável é opcional quando ela não é usada). O objeto [Key] associa a chave a um algoritmo: um token que especifique um algoritmo diferente (ou nenhum, [none]) seria rejeitado. O token válido se torna um [User], sem hash, junto com suas declarações (parâmetro chamado [claims]).
8.1.5. O autenticador: src/Security/TokenAuthenticator.php
Para cada requisição que passa pelo firewall, o [Symfony] chama os métodos do autenticador nesta ordem:
- linhas 28–31: [supports]: o autenticador está envolvido nesta requisição? Sim, se ela contiver o cookie do token. Caso contrário, nada acontece: o visitante permanece anônimo;
- linhas 35–44: [authenticate] constrói um passaporte: a identidade do usuário (um badge, [UserBadge]) e as credenciais a verificar. Um formulário de login padrão incluiria a senha digitada no passaporte, que o [Symfony] verificaria por conta própria. Aqui, a prova é o token, já verificado pelo [AuthService]: o passaporte se valida sozinho ([SelfValidatingPassport]). O badge contém o login e uma função que identifica o usuário: neste caso, o usuário descrito pelo token, sem consultar a lista de usuários (sem essa função, o [Symfony] solicitaria o usuário ao provider). Um token inválido lança uma exceção de autenticação;
- linhas 47–50: [onAuthenticationSuccess]: a autenticação foi bem-sucedida. Retornar [null] permite que a requisição prossiga até a ação com um usuário autenticado. (Um formulário de login redirecionaria aqui para a página inicial);
- linhas 53–58: [onAuthenticationFailure]: a autenticação falhou (token expirado ou forjado). A resposta redireciona para a página de login e aproveita para limpar o cookie: [clearCookie] adiciona à resposta um cookie vazio e já expirado;
- linhas 62–65: [start] é o método da interface [AuthenticationEntryPointInterface]: o ponto de entrada do firewall, ou seja, a resposta enviada a um visitante anônimo que solicita uma página protegida. Neste caso, um redirecionamento para a página de login.
O autenticador não nega o acesso: ele determina quem é o usuário, ou determina que o usuário é anônimo. Isso é autenticação. As negações são responsabilidade do controle de acesso.
8.1.6. Os controllers
- linhas 36–38: o formulário de login é protegido contra requisições forjadas, como todos os formulários (exemplo 21);
- linhas 40–45: o processo de login. Se ele falhar, o formulário é exibido novamente com o nome de usuário digitado e uma mensagem deliberadamente vaga: dizer “nome de usuário desconhecido” revelaria a um invasor quais nomes de usuário existem;
- Linhas 49–54: se houver sucesso, o token é armazenado em um cookie e o usuário é redirecionado para a página protegida (esquema PRG). O cookie é [httpOnly]: o [JavaScript] da página não pode lê-lo, o que protege o token contra a injeção de scripts (XSS); ele é [SameSite=Lax]: o navegador não o envia com uma requisição POST originada em outro site, o que protege a aplicação contra ataques CSRF; sua data de expiração ([withExpires], aqui um número de segundos desde 1970) é a mesma do token. Em produção, com HTTPS, acrescentaríamos [withSecure(true)]: o cookie nunca seria enviado por uma conexão não criptografada;
- Linhas 59–68: o logout exclui o cookie ([clearCookie]). Essa é uma ação POST, protegida por um token anti-CSRF: um simples link para [/logout], colocado em outro site ou dentro de uma imagem, não pode desconectar o usuário sem que ele saiba. Observe uma limitação dos tokens: o próprio token continua válido até expirar. Quem tiver feito uma cópia dele ainda poderia usá-lo. É por isso que seu tempo de vida é limitado.
O [Symfony] também pode cuidar sozinho do login por formulário (o autenticador [form_login]) e do logout (a opção de firewall [logout] ); mas eles armazenam o usuário na sessão, ao passo que queremos um token.
- linha 18: o atributo [#[CurrentUser]] fornece o usuário autenticado, aquele estabelecido pelo autenticador. A ação é protegida pela regra [access_control] de [security.yaml]: ela com certeza receberá um usuário. Também o obteríamos por meio de [$this->getUser()].
8.1.7. As views
- linha 6: o token anti-CSRF do formulário (exemplo 21);
- linha 9: o login digitado é exibido novamente após uma falha ([??]: uma string vazia quando a variável [login] não existe).
- linhas 8–10: o conteúdo do token, exibido para fins ilustrativos. Um laço [for] do [Twig] pode percorrer as chaves e os valores de um array associativo ([for key, value in ...]);
- linhas 13–16: o logout, por meio de um formulário reduzido a um único botão.
O usuário autenticado também está disponível em todas as views com o nome [app.user].
8.1.8. Execução
Vamos solicitar a página protegida [/profile] sem estar conectado:
Uma senha incorreta:

Login bem-sucedido. Com o [curl], é preciso primeiro solicitar o formulário para obter o token anti-CSRF e o cookie de sessão (exemplo 21) e, em seguida, enviar o formulário mantendo o cookie recebido:
O token é composto de três partes, separadas por pontos, cada uma codificada em Base64: o cabeçalho, o conteúdo e a assinatura. As duas primeiras partes podem ser decodificadas sem nenhuma chave:
(O [é] é escrito em sua forma escapada em JSON, [\u00e9].) O tempo de expiração é de uma hora (3.600 segundos) após a criação. No navegador, a página de perfil exibe esse mesmo conteúdo:

Um usuário malicioso modifica seu token: ele substitui o papel ***[USER]*** por ***[ADMIN]*** no conteúdo, recodifica essa parte em Base64 e mantém a assinatura original. O servidor recalcula a assinatura do conteúdo modificado, que não corresponde mais:
O token forjado é rejeitado e excluído (o valor [deleted] e a data expirada instruem o navegador a excluir o cookie). Para gerar uma assinatura válida, seria preciso conhecer a chave secreta — daí a importância de mantê-la em segredo e de escolher uma chave longa e aleatória.
8.2. Exemplo 26: papéis
O exemplo 26 acrescenta uma página de administração, restrita ao papel ADMIN. Somente os arquivos novos ou modificados são exibidos.
8.2.1. A configuração: config/packages/security.yaml
- Linhas 12–13: a hierarquia de papéis: o papel [ROLE_ADMIN] inclui o papel [ROLE_USER]. Um administrador tem, assim, todos os direitos de um usuário, sem precisar receber os dois papéis;
- Linha 25: o manipulador de acesso negado do firewall ([access_denied_handler]): a classe que gera a resposta enviada a um usuário autenticado que solicita uma página que ele não tem autorização para ver;
- Linhas 27–31: a página [/admin] poderia ser protegida aqui com uma regra adicional; em vez disso, nós a protegemos em seu controller, para demonstrar uma abordagem alternativa.
A diferença entre as duas respostas de negação é importante: um visitante anônimo que solicita uma página protegida é redirecionado para o ponto de entrada do firewall (a página de login, exemplo 25); um usuário autenticado que não tem o papel exigido recebe um erro 403 (Forbidden): fazer login seria inútil, pois ele já está autenticado.
8.2.2. Acesso negado: src/Security/AccessDenied.php
- linha 13: a classe implementa a interface [AccessDeniedHandlerInterface], cujo único método, [handle], retorna a resposta de negação;
- linha 21: a página de erro 403, gerada pelo [Twig] (como o listener [ErrorPage] do exemplo 24), com o código 403 ([Response::HTTP_FORBIDDEN], uma constante da classe [Response]).
Sem esse manipulador, a negação resultaria em uma exceção [AccessDeniedHttpException], e o usuário veria a página de erro 403 do [Symfony] (detalhada no modo de depuração). A página [templates/errors/403.html.twig] é uma página de erro padrão, com um link de volta ao perfil.
8.2.3. O controller: src/Controller/AdminController.php
- Linha 17: o atributo [#[IsGranted]] permite que a ação seja executada somente por um usuário que tenha a permissão exigida, neste caso o papel [ROLE_ADMIN]. Um visitante anônimo é redirecionado para o ponto de entrada; um usuário autenticado sem esse papel tem o acesso negado. Quando aplicado à classe, o atributo protegeria todas as suas ações.
O controller não faz nenhuma verificação por conta própria. No código, uma permissão seria verificada com [$this->isGranted('ROLE_ADMIN')] (que retorna um booleano) ou com [$this->denyAccessUnlessGranted('ROLE_ADMIN')] (que lança uma exceção de negação). Para regras mais granulares do que um papel (“um usuário só pode editar as próprias consultas”), o [Symfony] permite definir “voters” (voters): classes que determinam uma permissão, que [#[IsGranted]] e [is_granted] consultam como se fossem papéis.
8.2.4. A view do perfil
- Linhas 7–11: a função [is_granted] do [Twig] verifica a permissão de um usuário. Isso evita exibir um link que levaria a um erro; no entanto, é apenas um recurso de conveniência: a proteção real vem da própria ação.
8.2.5. Execução
Marie, com o papel USER, segue o link para a página de administração:

O administrador, por outro lado, tem acesso a ela:

Com o [curl]: um usuário com o papel USER (conectado como no exemplo 25, com os cookies armazenados no arquivo [token.txt]), seguido de um visitante anônimo:
Proteger as rotas uma a uma tem uma falha: se uma for esquecida, a página se torna acessível a todos. O estudo de caso inverterá essa lógica: todas as páginas de URL são protegidas por padrão por meio de uma regra [access_control] geral, e apenas algumas páginas de URL (a página de login e a página de cadastro) ficam isentas.
8.3. Exemplo 27: CAPTCHA e limite de tentativas
Um formulário de login é um alvo: um programa pode tentar milhares de senhas por minuto (ataque de força bruta). Duas proteções se complementam:
- um CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart): uma imagem contendo um código distorcido, fácil de ler para um ser humano, mas difícil para um programa;
- um limite de tentativas: após três tentativas malsucedidas, o endereço IP do cliente é bloqueado por um minuto.
O exemplo 27 se baseia no exemplo 25 e acrescenta essas duas medidas de segurança.
8.3.1. A imagem do CAPTCHA: src/Security/CaptchaDrawing.php
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | |
A imagem está no formato SVG (Scalable Vector Graphics): um desenho vetorial descrito em XML — ou seja, em texto — que o servidor gera sem uma biblioteca gráfica e que o navegador exibe diretamente na página. Esta classe é puro [PHP], sem nada específico de um framework: é a mesma da versão [Laravel] deste curso.
- Linhas 16–49: uma “fonte” minimalista: cada caractere é uma lista de traços, e cada traço é uma lista de coordenadas [x, y] em uma grade de 4 × 6. Os caracteres facilmente confundidos ([0] e [O], [1], [I] e [L]) são excluídos;
- Linhas 56–64: uma string aleatória escolhida entre os caracteres da fonte ([array_keys], as chaves da tabela). As funções [rand] e [mt_rand] do [PHP] produzem sequências de números previsíveis (quem conhece alguns valores consegue adivinhar os seguintes): são adequadas para simulações, não para segurança. [random_int] é um gerador criptográfico; ele é imprevisível;
- linhas 67–70: um número de ponto flutuante aleatório, gerado a partir de um inteiro aleatório ([PHP_INT_MAX] é o maior inteiro do [PHP]);
- linhas 77–118: o desenho. Cada caractere é redimensionado, girado e deslocado aleatoriamente, e cada um de seus pontos é ligeiramente deslocado; cada linha se torna um elemento [<path>] do SVG ([M]: deslocamento, [L]: linha). Três curvas ([C]: curva de Bézier) cruzam a imagem para atrapalhar os programas de reconhecimento. A função [sprintf] formata uma string: [%s] insere nela uma string, e [%.1f] insere um número com uma casa decimal. [str_split] divide uma string em caracteres.
A classe [Captcha] combina o identificador de um CAPTCHA com sua imagem:
8.3.2. O serviço de CAPTCHA: src/Security/CaptchaService.php
- Linhas 18–29: um novo CAPTCHA: um texto aleatório, um identificador aleatório e impossível de adivinhar, e a imagem. Para cada identificador, o servidor armazena a resposta esperada no cache (exemplo 20) por dez minutos: o método [expiresAfter] do item de cache define seu tempo de vida em segundos. Passado esse tempo, o cache o descarta automaticamente. A página recebe apenas o identificador e a imagem: a resposta nunca sai do servidor;
- linhas 32–46: a validação. O identificador vem do cliente: primeiro verificamos que ele é composto por dígitos hexadecimais ([ctype_xdigit]), já que certos caracteres ([{}()/\@:]) são proibidos em chaves de cache, o que lançaria uma exceção. O item é lido e depois removido do cache ([deleteItem]): o CAPTCHA é consumido em todos os casos, com sucesso ou não. Sem isso, um programa poderia tentar todas as respostas possíveis na mesma imagem. A comparação ignora maiúsculas e minúsculas ([strcasecmp] retorna 0 para duas strings iguais, independentemente de letras maiúsculas ou minúsculas) e os espaços ao redor da entrada ([trim]).
8.3.3. Limite de tentativas: config/packages/framework.yaml
- linha 11: locks (exemplo 20): o limitador os utiliza para garantir que duas requisições simultâneas não distorçam sua contagem;
- linhas 14–18: um limitador de taxa, chamado [login]. Um limitador de taxa distribui “tokens” (sem relação com o token JWT): cada ação restrita consome um e, quando não restam mais, a ação é negada. A política [fixed_window] (janela fixa) concede 3 tokens por período de 60 segundos, contados a partir do primeiro token consumido. Existem outras políticas: [sliding_window] (uma janela deslizante, mais regular) e [token_bucket] (um balde que se enche a uma taxa determinada). Os contadores são armazenados no cache da aplicação.
Para cada limitador declarado, o [Symfony] cria um serviço de fábrica de limitadores ([RateLimiterFactoryInterface]), que é obtido por injeção sob um nome de parâmetro formado pelo nome do limitador seguido de [Limiter]: [$loginLimiter].
8.3.4. O controller: src/Controller/AuthController.php
- linhas 21–26: o controller recebe a fábrica do limitador [login];
- linha 49: o limitador deste cliente, [create(key)], retorna um limitador que tem seu próprio contador sob essa chave — neste caso, o endereço IP do cliente ([getClientIp()]);
- linhas 53–57: um endereço bloqueado nem sequer é ouvido. [consume(0)] consulta o limitador sem consumir nada; o objeto [RateLimit] que ele retorna fornece o número de tokens restantes ([getRemainingTokens()]) e a data em que a ação voltará a ser permitida ([getRetryAfter()]), da qual podemos deduzir o número de segundos de espera;
- Linhas 60–68: o CAPTCHA é verificado antes da senha; verificá-lo custa quase nada, ao passo que o [bcrypt] é intencionalmente lento. Um programa que digite o CAPTCHA errado, portanto, não acionaria o [bcrypt]. Cada falha — seja do CAPTCHA ou da senha — consome um token ([consume()], que consome um por padrão). Após a terceira falha, não restam tokens: o endereço fica bloqueado até o fim da janela de 60 segundos, contada a partir da primeira falha;
- linha 70: um login bem-sucedido zera as tentativas malsucedidas ([reset()]);
- linhas 91–95: a cada exibição do formulário, um novo CAPTCHA é gerado, mesmo após uma tentativa malsucedida.
O SecurityBundle também oferece um limite de conexão integrado (a opção de firewall [login_throttling] ), que se aplica aos seus próprios autenticadores de login ([form_login]...), e não à nossa ação. Para limitar o número de requisições a uma rota, usaríamos um limitador da mesma maneira, seja dentro da ação, seja em um listener de [kernel.request]. Optamos por contar apenas as tentativas malsucedidas, para não incomodar um usuário que faz login normalmente.
8.3.5. A view: templates/auth/login.html.twig
- Linha 18: a imagem SVG é inserida na página como está, sem escape (filtro [raw], exemplo 14). Isso é legítimo: esse HTML foi gerado pelo servidor e não contém nenhuma entrada do usuário;
- linha 20: o identificador do CAPTCHA, em um campo oculto;
- linha 21: o navegador não sugere nenhuma entrada anterior para este campo.
8.3.6. Execução

Um código copiado incorretamente:

Após três tentativas malsucedidas, o endereço é bloqueado:

Com o [curl], quatro tentativas usando um identificador de CAPTCHA inventado (depois de obter, como no exemplo 25, o cookie de sessão e o token anti-CSRF):
Mesmo com a senha correta, a quarta tentativa é rejeitada sem ser processada.