8. Autenticación y autorización
Para cada solicitud surgen dos preguntas distintas:
- ¿Quién es el usuario? Esto es la autenticación: el usuario se ha identificado con un nombre de usuario y una contraseña, y cada solicitud posterior debe demostrar que proviene de él;
- ¿Tiene permiso para acceder a esta página? Esto es la autorización: en el caso de estudio, solo un usuario con el rol ADMIN administra los médicos y los clientes.
La prueba de identidad debe incluirse en cada solicitud. [Symfony] normalmente almacena al usuario conectado en su sesión (véase la sección sobre los ámbitos), que es la solución más simple para una aplicación web. En cambio, el caso de estudio, en todas sus versiones ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask], [Laravel]), utiliza un token (JWT, JSON Web Token), que usaremos aquí: después del inicio de sesión, el servidor genera un token que contiene la identidad del usuario y lo firma con una clave secreta (este es el principio de la cookie firmada del Ejemplo 23). El token se almacena en una cookie; el navegador la reenvía con cada solicitud; el servidor verifica la firma. El usuario puede leer su token, pero no modificarlo: cualquier modificación invalida la firma. El formato está estandarizado (RFC 7519), lo entienden todos los lenguajes de programación y el token incluye su fecha de expiración. Lo más importante es que el servidor no necesita almacenar nada: cualquier servidor que conozca la clave puede verificar el token.
[Symfony] tiene un componente de seguridad completo, integrado por SecurityBundle, cuyos elementos usaremos tal cual:
- las URL de la aplicación se distribuyen entre cortafuegos (firewalls), cada uno con su propio método de autenticación de usuarios;
- la autenticación está a cargo de los autenticadores (authenticators): objetos que determinan la identidad del usuario en cada solicitud. [Symfony] proporciona varios (formulario de inicio de sesión, sesión, token de API, etc.); escribiremos el nuestro, que lee el token JWT. El resto de la aplicación solo ve el resultado: el usuario autenticado, proporcionado por [#[CurrentUser]], [$this->getUser()] y, en las vistas, [app.user];
- los usuarios los proporciona un proveedor de usuarios, y sus contraseñas se procesan con hash mediante el componente PasswordHasher (algoritmo [bcrypt]);
- las autorizaciones se basan en roles: la protección de las páginas se describe mediante reglas de control de acceso ([access_control]) o mediante el atributo [#[IsGranted]] de las acciones; las vistas comprueban un derecho mediante [is_granted];
- Los intentos de inicio de sesión están limitados por el componente RateLimiter (Ejemplo 27).
Todo esto lo realizan los listeners de eventos del kernel (capítulo anterior): el cortafuegos escucha [kernel.request] (prioridad 8), [#[IsGranted]] se lee en [kernel.controller_arguments] y las denegaciones de acceso son excepciones, gestionadas en [kernel.exception].
La generación y la verificación de tokens las realiza la biblioteca [firebase/php-jwt], la más utilizada en [PHP], instalada por el archivo [composer.json] de los ejemplos. (Existe un bundle muy utilizado para tokens —JWT y [LexikJWTAuthenticationBundle]— diseñado para API; para una aplicación web bastan unas pocas líneas, que ilustran mejor el mecanismo.)
8.1. Ejemplo 25: inicio de sesión, token, página protegida
8.1.1. Configuración: .env, bundles.php y framework.yaml
El token se firma con una clave secreta, que no debe estar codificada en el código. Es hora de separar realmente la configuración del código. Los ajustes específicos de una instalación están en el archivo [.env] (Ejemplo 01), que ahora contiene tres líneas nuevas (un comentario, seguido de dos variables):
El estándar exige que el algoritmo utilizado (HMAC-SHA256) tenga una clave de al menos 256 bits, es decir, 32 bytes; la biblioteca rechaza cualquier clave más corta. El código en sí no lee directamente el archivo [.env]: el componente [Dotenv] (ejemplo 01) lo ha convertido en variables de entorno, que el contenedor proporciona a los servicios que las solicitan (lo veremos con el servicio [AuthService]). Una variable de entorno real tiene prioridad sobre el archivo [.env]: en [Linux] o [macOS], la aplicación se iniciaría con una clave diferente de la siguiente manera:
y en [Windows] (PowerShell):
(La opción [-d variables_order=EGPCS] indica a [PHP] que llene el arreglo [$_ENV] con las variables de entorno, lo que su configuración predeterminada no siempre hace.) En producción, los secretos suelen confiarse a la bóveda de [Symfony] (secrets vault, comando [bin/console secrets:set]), que los almacena cifrados dentro del proyecto.
SecurityBundle se agrega a la lista de bundles:
La sesión se utiliza aquí únicamente para el token anti-CSRF del formulario de inicio de sesión (Ejemplo 21):
8.1.2. Configuración de seguridad: config/packages/security.yaml
- líneas 4–6: el algoritmo de hash de contraseñas para los usuarios de la clase [User]: [bcrypt]. (El valor [auto] seleccionaría el mejor algoritmo disponible y podría verificar hashes de otros algoritmos);
- líneas 9–11: el proveedor de usuarios, el servicio que encuentra a un usuario a partir de su ID (aquí, nuestra clase [UsersService]). [Symfony] proporciona varios: [memory] (una lista escrita en este archivo), [entity] (una tabla de base de datos; véase el caso de estudio)...;
- Líneas 14–27: los cortafuegos. Cada uno se aplica a las entradas de URL que coinciden con su patrón ([pattern]), y se selecciona la primera entrada que coincide. El primero, [resources], cubre los archivos de [Bootstrap] (Ejemplo 15), sin seguridad ([security: false]): no hay necesidad de buscar un usuario para servir una hoja de estilos. El segundo, [main], no tiene un motivo específico: cubre todas las demás URL;
- línea 23: el cortafuegos es sin estado (stateless): el usuario autenticado no se almacena en la sesión; se le identifica en cada solicitud a partir de su token;
- Líneas 26–27: el autenticador del cortafuegos, nuestra clase [TokenAuthenticator];
- Líneas 31–32: control de acceso: una lista de reglas, examinadas en orden, de las cuales se aplica la primera que corresponde a la URL. Las URL que comienzan con [/profile] requieren un usuario autenticado ([IS_AUTHENTICATED]); las demás son públicas.
En un proyecto estándar, este archivo lo escribe [Symfony Flex] cuando se instala el bundle ([composer require security]), y el comando [bin/console make:user] de [MakerBundle] escribe la clase de usuario y su proveedor.
8.1.3. Usuarios: src/Security/User.php y UsersService.php
- Línea 11: un usuario. [Symfony] espera que los usuarios autenticados implementen la interfaz [UserInterface]: sus métodos le proporcionan el identificador y los roles del usuario. La interfaz [PasswordAuthenticatedUserInterface] añade la contraseña con hash. En una aplicación típica, la entidad [Doctrine] de la tabla de usuarios (próximo capítulo) implementa estos métodos;
- Líneas 13–23: el inicio de sesión, el nombre, el rol, el hash de la contraseña y el contenido del token que autenticó al usuario (vacío para un usuario recuperado de la lista de usuarios). Un servidor nunca almacena una contraseña, ni siquiera cifrada: si la base de datos fuera robada, las contraseñas también lo serían (y muchas personas usan la misma contraseña en todas partes). Almacena el resultado de una función hash, una función unidireccional: se puede calcular el hash de una contraseña, pero no es posible recuperar la contraseña a partir de su hash. Para verificar una contraseña ingresada, se calcula su hash y se compara con el almacenado;
- líneas 32–35: roles, tal como los define [Symfony]: cadenas que comienzan con [ROLE_]. El rol [USER] del caso de estudio se convierte en [ROLE_USER].
- Líneas 17–20: dos usuarios de prueba, definidos directamente en el código (el ejemplo 28 y el caso de estudio los almacenarán en una base de datos): para cada inicio de sesión, el nombre, el rol y el hash de la contraseña. El hash se genera con el algoritmo bcrypt, diseñado para contraseñas. Tiene dos características distintivas. Es deliberadamente lento, con un nivel de lentitud ajustable (el costo, aquí fijado en 10: 2^10 ciclos de cálculo, lo que da como resultado el hash [$10$]): unas pocas decenas de milisegundos, imperceptibles para un usuario, pero que hacen muy costoso para un atacante probar miles de millones de contraseñas. Es con sal: una sal generada aleatoriamente se mezcla con la contraseña antes de aplicar el hash y se almacena dentro del propio hash (los 22 caracteres que siguen a [$10$]); así, dos usuarios con la misma contraseña tendrán hashes diferentes. Los hashes se calcularon una vez por todas con la función [password_hash] de [PHP] (línea 16), o con el comando [bin/console security:hash-password] de [Symfony]: calcularlos en cada solicitud sería una pérdida de tiempo innecesaria, ya que la aplicación se reconstruye con cada solicitud. [bcrypt] solo tiene en cuenta los primeros 72 bytes de una contraseña: el caso de estudio lo tiene en cuenta;
- líneas 22–29: el usuario de un inicio de sesión, o [null]. [isset] verifica la existencia de una clave; la asignación [[$name, $role, $hash] = ...] desestructura un arreglo: cada variable recibe el elemento correspondiente;
- líneas 32–47: los tres métodos de la interfaz [UserProviderInterface], que convierten la clase en un proveedor de usuarios: [loadUserByIdentifier] devuelve el usuario asociado a un identificador, o lanza la excepción [UserNotFoundException]; [refreshUser] recarga el usuario almacenado en la sesión (innecesario con un firewall sin estado); [supportsClass] especifica la clase de los usuarios proporcionados. El operador [??] seguido de [throw] lanza la excepción cuando la expresión del lado izquierdo se evalúa como [null].
8.1.4. El servicio de autenticación: src/Security/AuthService.php
- Líneas 17–26: el servicio recibe el proveedor de usuarios, el servicio de hash de contraseñas ([UserPasswordHasherInterface], que aplica el algoritmo seleccionado en [security.yaml]) y dos valores de configuración. El atributo [#[Autowire(env: 'NAME')]] proporciona el valor de una variable de entorno; un prefijo lo convierte: [int:] a entero (hay otros: [bool:], [json:], [base64:]...). La duración de vida es una propiedad pública de solo lectura: el controlador la usará;
- líneas 31–41: verificación de un nombre de usuario y una contraseña. [isPasswordValid] calcula el hash de la contraseña ingresada usando la sal del hash almacenado y compara los dos hashes. Un nombre de usuario desconocido y una contraseña incorrecta producen el mismo resultado, [null];
- Líneas 44–56: generación del token. El token contiene un arreglo de afirmaciones (claims) sobre el usuario. Algunas tienen nombres estandarizados: [sub] (subject), el identificador del usuario; [iat] (issued at), la fecha de creación; [exp] (expiration), la fecha de expiración. Las fechas se expresan en segundos transcurridos desde el 1 de enero de 1970 (la función [time()] de [PHP]). Los demás campos son opcionales: aquí, el nombre y el rol. [JWT::encode] genera el token y lo firma con el algoritmo [HS256] (HMAC-SHA256, una firma con una clave secreta compartida);
- líneas 60–69: verificación del token. [JWT::decode] verifica la firma y la fecha de expiración, y luego devuelve las afirmaciones (un objeto, convertido en arreglo mediante [(array)]). Cualquier anomalía (token falsificado, expirado o mal formado) lanza una excepción; [catch (Throwable)] las captura todas ([Throwable] es la interfaz de todas las excepciones y errores de [PHP]; el nombre de la variable es opcional cuando no se usa). El objeto [Key] asocia la clave con un algoritmo: un token que especifique un algoritmo diferente (o ninguno, [none]) sería rechazado. El token válido se convierte en un [User], sin hash, junto con sus claims (parámetro llamado [claims]).
8.1.5. El autenticador: src/Security/TokenAuthenticator.php
Para cada solicitud que pasa por el firewall, [Symfony] llama a los métodos del autenticador en este orden:
- líneas 28–31: [supports]: ¿participa el autenticador en esta solicitud? Sí, si contiene la cookie del token. De lo contrario, no ocurre nada: el visitante sigue siendo anónimo;
- líneas 35–44: [authenticate] construye un pasaporte: la identidad del usuario (una credencial, [UserBadge]) y las credenciales que se deben verificar. Un formulario de inicio de sesión estándar incluiría la contraseña ingresada en el pasaporte, que [Symfony] verificaría por sí mismo. Aquí, la prueba es el token, ya verificado por [AuthService]: el pasaporte se valida a sí mismo ([SelfValidatingPassport]). La credencial contiene el inicio de sesión y una función que identifica al usuario: en este caso, el usuario descrito por el token, sin consultar la lista de usuarios (sin esta función, [Symfony] solicitaría el usuario al proveedor). Un token no válido lanza una excepción de autenticación;
- líneas 47–50: [onAuthenticationSuccess]: la autenticación se realizó con éxito. Devolver [null] permite que la solicitud llegue a la acción con un usuario autenticado. (Un formulario de inicio de sesión redirigiría aquí a la página de inicio);
- líneas 53–58: [onAuthenticationFailure]: la autenticación falló (token expirado o falsificado). La respuesta redirige a la página de inicio de sesión y aprovecha para borrar la cookie: [clearCookie] agrega a la respuesta una cookie vacía y ya expirada;
- líneas 62–65: [start] es el método de la interfaz [AuthenticationEntryPointInterface]: el punto de entrada del firewall, es decir, la respuesta enviada a un visitante anónimo que solicita una página protegida. En este caso, una redirección a la página de inicio de sesión.
El autenticador no deniega el acceso: determina quién es el usuario, o determina que el usuario es anónimo. Esto es la autenticación. Las denegaciones son responsabilidad del control de acceso.
8.1.6. Los controladores
- líneas 36–38: el formulario de inicio de sesión está protegido contra solicitudes falsificadas, como todos los formularios (ejemplo 21);
- líneas 40–45: el proceso de inicio de sesión. Si falla, el formulario se vuelve a mostrar con el nombre de usuario ingresado y un mensaje deliberadamente vago: decir «nombre de usuario desconocido» revelaría a un atacante qué nombres de usuario existen;
- Líneas 49–54: si tiene éxito, el token se almacena en una cookie y el usuario es redirigido a la página protegida (patrón PRG). La cookie es [httpOnly]: el [JavaScript] de la página no puede leerla, lo que protege el token contra la inyección de scripts (XSS); es [SameSite=Lax]: el navegador no la envía con una solicitud POST proveniente de otro sitio, lo que protege la aplicación contra ataques CSRF; su fecha de expiración ([withExpires], aquí un número de segundos desde 1970) es la misma que la del token. En producción, con HTTPS, se agregaría [withSecure(true)]: la cookie nunca se enviaría a través de una conexión sin cifrar;
- Líneas 59–68: cerrar sesión elimina la cookie ([clearCookie]). Es una acción POST, protegida por un token anti-CSRF: un simple enlace a [/logout], colocado en otro sitio o dentro de una imagen, no puede cerrar la sesión del usuario sin que este lo sepa. Cabe señalar una limitación de los tokens: el token en sí sigue siendo válido hasta que expira. Alguien que haya hecho una copia podría seguir usándolo. Por eso su duración de vida es limitada.
[Symfony] también puede gestionar por sí solo el inicio de sesión mediante formulario (el autenticador [form_login]) y el cierre de sesión (la opción de firewall [logout] ); pero almacenan al usuario en la sesión, mientras que nosotros queremos un token.
- línea 18: el atributo [#[CurrentUser]] proporciona el usuario autenticado, el establecido por el autenticador. La acción está protegida por la regla [access_control] de [security.yaml]: se garantiza que recibirá un usuario. También lo obtendríamos mediante [$this->getUser()].
8.1.7. Las vistas
- línea 6: el token anti-CSRF del formulario (ejemplo 21);
- línea 9: el inicio de sesión ingresado se vuelve a mostrar después de un fallo ([??]: una cadena vacía cuando la variable [login] no existe).
- líneas 8–10: el contenido del token, mostrado con fines ilustrativos. Un bucle [for] de [Twig] puede recorrer las claves y los valores de un arreglo asociativo ([for key, value in ...]);
- líneas 13–16: cierre de sesión, mediante un formulario reducido a un solo botón.
El usuario autenticado también está disponible en todas las vistas con el nombre [app.user].
8.1.8. Ejecución
Solicitemos la página protegida [/profile] sin haber iniciado sesión:
Una contraseña incorrecta:

Inicio de sesión exitoso. Con [curl], primero se debe solicitar el formulario para obtener el token anti-CSRF y la cookie de sesión (ejemplo 21), y luego enviar el formulario conservando la cookie recibida:
El token consta de tres partes, separadas por puntos, cada una codificada en Base64: el encabezado, el contenido y la firma. Las dos primeras partes se pueden decodificar sin ninguna clave:
(La [é] se escribe en su forma escapada en JSON, [\u00e9].) El tiempo de expiración es de una hora (3600 segundos) después de la creación. En el navegador, la página de perfil muestra este mismo contenido:

Un usuario malintencionado modifica su token: reemplaza el rol ***[USER]*** por ***[ADMIN]*** en el contenido, vuelve a codificar esta parte en Base64 y conserva la firma original. El servidor recalcula la firma del contenido modificado, que ya no coincide:
El token falsificado es rechazado y eliminado (el valor [deleted] y la fecha expirada le indican al navegador que elimine la cookie). Para generar una firma válida, habría que conocer la clave secreta; de ahí la importancia de mantenerla en secreto y de elegir una clave larga y aleatoria.
8.2. Ejemplo 26: roles
El ejemplo 26 agrega una página de administración, restringida al rol ADMIN. Solo se muestran los archivos nuevos o modificados.
8.2.1. La configuración: config/packages/security.yaml
- Líneas 12–13: la jerarquía de roles: el rol [ROLE_ADMIN] incluye el rol [ROLE_USER]. Un administrador tiene así todos los derechos de un usuario sin necesidad de que se le asignen ambos roles;
- Línea 25: el controlador de acceso denegado del firewall ([access_denied_handler]): la clase que genera la respuesta enviada a un usuario autenticado que solicita una página que no está autorizado a ver;
- Líneas 27–31: la página [/admin] podría protegerse aquí con una regla adicional; en cambio, la protegemos en su controlador para demostrar un enfoque alternativo.
La diferencia entre las dos respuestas de denegación es importante: un visitante anónimo que solicita una página protegida es redirigido al punto de entrada del firewall (la página de inicio de sesión, ejemplo 25); un usuario autenticado que no tiene el rol requerido recibe un error 403 (Forbidden): iniciar sesión sería inútil, ya que ya está autenticado.
8.2.2. Acceso denegado: src/Security/AccessDenied.php
- línea 13: la clase implementa la interfaz [AccessDeniedHandlerInterface], cuyo único método, [handle], devuelve la respuesta de denegación;
- línea 21: la página de error 403, generada por [Twig] (como el listener [ErrorPage] del ejemplo 24), con el código 403 ([Response::HTTP_FORBIDDEN], una constante de la clase [Response]).
Sin este controlador, la denegación daría lugar a una excepción [AccessDeniedHttpException], y el usuario vería la página de error 403 de [Symfony] (detallada en modo de depuración). La página [templates/errors/403.html.twig] es una página de error estándar, con un enlace de regreso al perfil.
8.2.3. El controlador: src/Controller/AdminController.php
- Línea 17: el atributo [#[IsGranted]] permite que la acción solo la ejecute un usuario que tenga el permiso requerido, en este caso el rol [ROLE_ADMIN]. Un visitante anónimo es redirigido al punto de entrada; a un usuario autenticado sin este rol se le deniega el acceso. Si se aplica a la clase, el atributo protegería todas sus acciones.
El controlador no realiza ninguna verificación por sí mismo. En el código, un permiso se verificaría mediante [$this->isGranted('ROLE_ADMIN')] (que devuelve un booleano) o [$this->denyAccessUnlessGranted('ROLE_ADMIN')] (que lanza una excepción de denegación). Para reglas más granulares que un rol («un usuario solo puede editar sus propias citas»), [Symfony] permite definir «voters» (voters): clases que determinan un permiso, que [#[IsGranted]] y [is_granted] consultan como si fueran roles.
8.2.4. La vista del perfil
- Líneas 7–11: la función [is_granted] de [Twig] verifica el permiso de un usuario. Esto evita mostrar un enlace que conduciría a un error; sin embargo, es solo una comodidad: la protección real proviene de la propia acción.
8.2.5. Ejecución
Marie, con el rol USER, sigue el enlace a la página de administración:

El administrador, en cambio, tiene acceso a ella:

Con [curl]: un usuario con el rol USER (que inició sesión como en el ejemplo 25, con las cookies almacenadas en el archivo [token.txt]), seguido de un visitante anónimo:
Proteger las rutas una por una tiene un defecto: si se olvida una, la página queda accesible para todos. El caso de estudio invertirá esta lógica: todas las páginas URL están protegidas por defecto mediante una regla [access_control] general, y solo unas pocas páginas URL (la página de inicio de sesión, la página de registro) están exentas.
8.3. Ejemplo 27: CAPTCHA y límites de intentos
Un formulario de inicio de sesión es un objetivo: un programa puede probar miles de contraseñas por minuto (ataque de fuerza bruta). Dos protecciones se complementan:
- un CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart): una imagen que contiene un código distorsionado, fácil de leer para un ser humano pero difícil para un programa;
- un límite de intentos: después de tres intentos fallidos, la dirección IP del cliente se bloquea durante un minuto.
El ejemplo 27 se basa en el ejemplo 25 y agrega estas dos medidas de seguridad.
8.3.1. La imagen 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 | |
La imagen está en formato SVG (Scalable Vector Graphics): un dibujo vectorial descrito en XML (es decir, texto), que el servidor genera sin una biblioteca gráfica y que el navegador muestra directamente en la página. Esta clase es [PHP] puro, sin nada específico de un framework: es la misma que en la versión [Laravel] de este curso.
- Líneas 16–49: una «fuente» minimalista: cada carácter es una lista de trazos, y cada trazo es una lista de coordenadas [x, y] en una cuadrícula de 4 × 6. Se excluyen los caracteres que se confunden fácilmente ([0] y [O], [1], [I] y [L]);
- Líneas 56–64: una cadena aleatoria seleccionada entre los caracteres de la fuente ([array_keys], las claves del arreglo). Las funciones [rand] y [mt_rand] de [PHP] producen secuencias de números predecibles (cualquiera que conozca unos cuantos valores puede adivinar los siguientes): son adecuadas para simulaciones, no para seguridad. [random_int] es un generador criptográfico; es impredecible;
- líneas 67–70: un número de punto flotante aleatorio, generado a partir de un entero aleatorio ([PHP_INT_MAX] es el entero más grande en [PHP]);
- líneas 77–118: el dibujo. Cada carácter se escala, se rota y se desplaza de forma aleatoria, y cada uno de sus puntos se desvía ligeramente; cada línea se convierte en un elemento [<path>] del SVG ([M]: desplazamiento, [L]: línea). Tres curvas ([C]: curva de Bézier) cruzan la imagen para interferir con los programas de reconocimiento. La función [sprintf] formatea una cadena: [%s] inserta una cadena en ella, y [%.1f] inserta un número con un decimal. [str_split] divide una cadena en caracteres.
La clase [Captcha] combina el identificador de un CAPTCHA con su imagen:
8.3.2. El servicio CAPTCHA: src/Security/CaptchaService.php
- Líneas 18–29: un nuevo CAPTCHA: un texto aleatorio, un identificador aleatorio e imposible de adivinar, y la imagen. Para cada identificador, el servidor almacena la respuesta esperada en la caché (ejemplo 20) durante diez minutos: el método [expiresAfter] del elemento de caché establece su duración de vida en segundos. Transcurrido este tiempo, la caché lo descarta automáticamente. La página recibe solo el identificador y la imagen: la respuesta nunca sale del servidor;
- líneas 32–46: la validación. El identificador proviene del cliente: primero verificamos que conste de dígitos hexadecimales ([ctype_xdigit]), ya que ciertos caracteres ([{}()/\@:]) están prohibidos en las claves de la caché, lo que lanzaría una excepción. El elemento se lee y luego se elimina de la caché ([deleteItem]): el CAPTCHA se consume en todos los casos, tenga éxito o no. Sin esto, un programa podría probar todas las respuestas posibles sobre la misma imagen. La comparación ignora las mayúsculas y minúsculas ([strcasecmp] devuelve 0 para dos cadenas iguales, sin importar si las letras son mayúsculas o minúsculas) y los espacios alrededor de la entrada ([trim]).
8.3.3. Límite de intentos: config/packages/framework.yaml
- línea 11: bloqueos (ejemplo 20): el limitador los utiliza para garantizar que dos solicitudes simultáneas no alteren su recuento;
- líneas 14–18: un limitador de frecuencia, llamado [login]. Un limitador de frecuencia distribuye «tokens» (sin relación con el token JWT): cada acción restringida consume uno, y cuando ya no quedan, la acción se deniega. La política [fixed_window] (ventana fija) otorga 3 tokens por período de 60 segundos, contados a partir del primer token consumido. Existen otras políticas: [sliding_window] (una ventana deslizante, más regular), [token_bucket] (un cubo que se llena a una tasa determinada). Los contadores se almacenan en la caché de la aplicación.
Para cada limitador declarado, [Symfony] crea un servicio de fábrica de limitadores ([RateLimiterFactoryInterface]), que se obtiene mediante inyección con un nombre de parámetro formado por el nombre del limitador seguido de [Limiter]: [$loginLimiter].
8.3.4. El controlador: src/Controller/AuthController.php
- líneas 21–26: el controlador recibe la fábrica del limitador [login];
- línea 49: el limitador de este cliente, [create(key)], devuelve un limitador que tiene su propio contador bajo esta clave; en este caso, la dirección IP del cliente ([getClientIp()]);
- líneas 53–57: a una dirección bloqueada ni siquiera se le presta atención. [consume(0)] consulta el limitador sin consumir nada; el objeto [RateLimit] que devuelve proporciona el número de tokens restantes ([getRemainingTokens()]) y la fecha en que la acción volverá a estar permitida ([getRetryAfter()]), de la cual se puede deducir el número de segundos que hay que esperar;
- Líneas 60–68: el CAPTCHA se verifica antes que la contraseña; verificarlo casi no cuesta nada, mientras que [bcrypt] es deliberadamente lento. Por lo tanto, un programa que ingrese un CAPTCHA incorrecto no activaría [bcrypt]. Cada fallo, ya sea del CAPTCHA o de la contraseña, consume un token ([consume()], que consume uno por defecto). Después del tercer fallo, no quedan tokens: la dirección queda bloqueada hasta el final de la ventana de 60 segundos, contada a partir del primer fallo;
- línea 70: un inicio de sesión exitoso borra los intentos fallidos ([reset()]);
- líneas 91–95: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA, incluso después de un intento fallido.
SecurityBundle también ofrece un límite de conexiones integrado (la opción de firewall [login_throttling] ), que se aplica a sus propios autenticadores de inicio de sesión ([form_login]...), no a nuestra acción. Para limitar el número de solicitudes de una ruta, usaríamos un limitador de la misma manera, ya sea dentro de la acción o en un listener de [kernel.request]. Elegimos contar únicamente los intentos fallidos, para no incomodar a un usuario que inicia sesión con normalidad.
8.3.5. La vista: templates/auth/login.html.twig
- Línea 18: la imagen SVG se inserta en la página tal cual, sin escape (filtro [raw], ejemplo 14). Esto es legítimo: este HTML lo generó el servidor; no contiene ninguna entrada del usuario;
- línea 20: el identificador del CAPTCHA, en un campo oculto;
- línea 21: el navegador no sugiere entradas anteriores para este campo.
8.3.6. Ejecución

Un código copiado incorrectamente:

Después de tres intentos fallidos, la dirección queda bloqueada:

Con [curl], cuatro intentos usando un identificador de CAPTCHA inventado (después de obtener, como en el ejemplo 25, la cookie de sesión y el token anti-CSRF):
Incluso con la contraseña correcta, el cuarto intento se rechaza sin ser procesado.