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 el usuario permiso para acceder a esta página? Esto es la autorización: en el caso de estudio, solo un usuario con el rol ADMIN gestiona los médicos y los clientes.
Como el servidor no tiene estado (capítulo 6), la prueba de identidad debe incluirse en cada solicitud. Se utiliza un token JWT ([JSON Web Token]): tras el inicio de sesión, el servidor genera un token que contiene la identidad del usuario y lo firma con una clave secreta. El token se almacena en una cookie; el navegador lo reenvía con cada solicitud; el servidor verifica la firma. El usuario puede leer su token, pero no puede modificarlo: cualquier modificación invalida la firma.
[ASP.NET Core] distingue claramente las dos cuestiones:
- la autenticación la gestionan un middleware ([UseAuthentication]) y un esquema de autenticación: en este caso, el esquema [JwtBearer], proporcionado por el paquete [NuGet] [Microsoft.AspNetCore.Authentication.JwtBearer]. En cada solicitud, busca un token, lo verifica y deduce de él el usuario, [HttpContext.User];
- la autorización la gestiona el atributo [[Authorize]], verificado por el middleware [UseAuthorization]: compara los requisitos de la acción con lo que se sabe del usuario.
Los ejemplos de este capítulo usan dos paquetes [NuGet]: [Microsoft.AspNetCore.Authentication.JwtBearer] y [BCrypt.Net-Next] (hash de contraseñas). Están declarados en el archivo de proyecto; el comando [dotnet build] (o [dotnet run]) los descarga desde nuget.org durante la primera compilación: por lo tanto, se requiere una conexión a Internet.
8.1. Ejemplo 25: inicio de sesión, token, página protegida
| 25-jwt/
├── Auth/
│ ├── AuthService.cs
│ └── UsersService.cs
├── Controllers/
│ ├── AuthController.cs
│ └── ProfileController.cs
├── Views/
│ ├── Auth/
│ │ └── Login.cshtml
│ ├── Profile/
│ │ └── Profile.cshtml
│ ├── Shared/
│ │ └── _Layout.cshtml
│ ├── _ViewImports.cshtml
│ └── _ViewStart.cshtml
├── appsettings.json
├── Example25.csproj
└── Program.cs
|
El archivo [Example25.csproj]:
| <Project Sdk="Microsoft.NET.Sdk.Web">
<ItemGroup>
<!-- autenticación con token JWT (verificación del token) -->
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.0" />
<!-- hash de contraseñas (bcrypt) -->
<PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
</ItemGroup>
</Project>
|
- Líneas 5–7: los paquetes [NuGet] utilizados y sus versiones. Los elementos comunes a todos los ejemplos (versión de [.NET]...) están en el archivo [Directory.Build.props] de la carpeta [examples].
El archivo [appsettings.json]:
| {
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"Jwt": {
"Secret": "a-secret-key-of-at-least-32-characters-for-example-25",
"DurationMinutes": 60
}
}
|
- Líneas 9–11: una sección de configuración específica de la aplicación: la clave usada para firmar los tokens y su tiempo de vida. Cualquiera que conozca la clave puede generar tokens válidos: en producción, no se almacena en un archivo de proyecto; se proporciona mediante una variable de entorno ([Jwt__Secret]) o una bóveda de secretos. El algoritmo utilizado (HMAC-SHA256) exige una clave de al menos 32 bytes.
El archivo [Auth/UsersService.cs]:
| namespace Example25.Auth;
public record User(string Login, string Name, string Role, string PasswordHash);
// los usuarios, en memoria (el próximo capítulo los pondrá en una base de datos)
public class UsersService
{
private readonly List<User> users =
[
// una contraseña NUNCA se guarda, solo su hash
Create("marie", "Marie Pélissier", "USER", "marie"),
Create("admin", "Administrator", "ADMIN", "admin"),
];
public User? Find(string login) =>
users.Find(u => u.Login == login);
// bcrypt, con un costo de 10: 2^10 rondas de cálculo, deliberadamente lento
private static User Create(string login, string name, string role, string password) =>
new(login, name, role, BCrypt.Net.BCrypt.HashPassword(password, 10));
}
|
- línea 3: un usuario, junto con su rol;
- líneas 10–12: una contraseña nunca se almacena; solo se conserva su hash, una huella calculada mediante una función unidireccional. Es posible verificar que una contraseña corresponde a una huella, pero no recuperar la contraseña a partir de la huella;
- líneas 19–20: [BCrypt.Net.BCrypt.HashPassword(password, 10)] calcula el hash con el algoritmo [bcrypt]. El 10 representa el “costo”: [bcrypt] es deliberadamente lento (2¹⁰ ciclos de cálculo) para disuadir a quien intente millones de contraseñas. Dos hashes de la misma contraseña son diferentes (se agrega una “sal” aleatoria): [BCrypt.Verify] se encarga de verificarlos.
El archivo [Auth/AuthService.cs]:
| using System.Text;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
namespace Example25.Auth;
public class AuthService(UsersService users, IConfiguration configuration)
{
// el nombre de la cookie que lleva el token
public const string Cookie = "token";
// la clave que firma los tokens, leída de appsettings.json (sección Jwt)
public static SymmetricSecurityKey Key(IConfiguration configuration) =>
new(Encoding.UTF8.GetBytes(configuration["Jwt:Secret"]!));
// null si el inicio de sesión es desconocido o la contraseña es incorrecta
public User? Validate(string? login, string? password)
{
var user = users.Find(login ?? "");
if (user is null || password is null)
{
return null;
}
return BCrypt.Net.BCrypt.Verify(password, user.PasswordHash) ? user : null;
}
// el token JWT del usuario, firmado con la clave secreta
public string CreateToken(User user)
{
var descriptor = new SecurityTokenDescriptor
{
// el contenido del token: los "claims" (afirmaciones sobre el usuario)
Claims = new Dictionary<string, object>
{
["sub"] = user.Login,
["name"] = user.Name,
["role"] = user.Role,
},
Expires = DateTime.UtcNow.AddMinutes(configuration.GetValue<int>("Jwt:DurationMinutes")),
SigningCredentials = new SigningCredentials(Key(configuration), SecurityAlgorithms.HmacSha256),
};
return new JsonWebTokenHandler().CreateToken(descriptor);
}
}
|
Analicemos este código:
- línea 10: el nombre de la cookie que transporta el token;
- Líneas 13–14: la clave de firma, generada a partir del texto de [appsettings.json]. [IConfiguration] da acceso a la configuración; ["Jwt:Secret"] designa la propiedad [Secret] de la sección [Jwt]. La misma clave se usa para firmar y verificar los tokens (algoritmo simétrico);
- líneas 17–24: verificación del nombre de usuario y la contraseña;
- líneas 33–37: el contenido del token, los claims (afirmaciones sobre el usuario). [sub] ([subject]) es el nombre convencional del identificador del usuario. Incluimos lo que necesitan las páginas (nombre, rol) para no tener que consultar la base de datos en cada solicitud;
- línea 39: la fecha de expiración del token;
- línea 40: la clave y el algoritmo de firma;
- línea 42: la clase [JsonWebTokenHandler] (paquete [Microsoft.IdentityModel.JsonWebTokens], proporcionado por [JwtBearer]) genera el token firmado.
El archivo [Program.cs]:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example25.Auth;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Extensions.FileProviders;
using Microsoft.IdentityModel.Tokens;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
builder.Services.AddSingleton<UsersService>();
builder.Services.AddSingleton<AuthService>();
// autenticación: un token JWT, verificado en cada solicitud
builder.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.MapInboundClaims = false; // conservar los nombres de los claims tal cual ("sub", "role"...)
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = AuthService.Key(builder.Configuration), // la firma debe ser la nuestra
ValidateLifetime = true, // el token no debe estar vencido
ValidateIssuer = false,
ValidateAudience = false,
NameClaimType = "name", // User.Identity.Name
RoleClaimType = "role", // [Authorize(Roles = ...)], User.IsInRole(...)
};
options.Events = new JwtBearerEvents
{
// 1. el token se lee de la cookie (y no del encabezado Authorization)
OnMessageReceived = context =>
{
context.Token = context.Request.Cookies[AuthService.Cookie];
return Task.CompletedTask;
},
// 2. página protegida sin un token válido: a la página de inicio de sesión
OnChallenge = context =>
{
context.HandleResponse(); // construimos la respuesta nosotros mismos (sin 401)
context.Response.Redirect("/login");
return Task.CompletedTask;
},
};
});
builder.Services.AddAuthorization();
var app = builder.Build();
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.UseAuthentication(); // ¿quién es? -> HttpContext.User
app.UseAuthorization(); // ¿está permitido? -> [Authorize]
app.MapControllers();
app.Run();
|
Comentemos este código:
- líneas 16–17: declaramos el esquema de autenticación [JwtBearer] y lo establecemos como esquema predeterminado;
- línea 19: de forma predeterminada, [JwtBearer] renombra ciertos claims con nombres largos heredados de las tecnologías de Microsoft ([role] pasaría a ser [http://schemas.microsoft.com/ws/2008/06/identity/claims/role]). Conservamos los nombres del token;
- Líneas 20–26: las comprobaciones realizadas en cada token: la firma (con nuestra clave) y la fecha de expiración. Nuestros tokens no especifican ni el emisor ([issuer]) ni el destinatario ([audience]), por lo que no los verificamos;
- líneas 27–28: qué claim contiene el nombre del usuario ([User.Identity.Name]) y cuál contiene su rol ([[Authorize(Roles = ...)]], [User.IsInRole(...)]);
- líneas 33–36: los eventos de [JwtBearer] permiten personalizar su comportamiento. De forma predeterminada, busca el token en el encabezado [Authorization: Bearer ...] de la solicitud: así funciona un cliente [JavaScript] o una aplicación móvil. Un navegador no agrega este encabezado por sí solo: el token se recupera de la cookie;
- líneas 39–42: el desafío (challenge) se produce cuando se solicita una página protegida sin un token válido. De forma predeterminada, la respuesta es un error 401 sin contenido: útil para un cliente [JavaScript], pero desconcertante para un usuario. Se redirige al usuario a la página de inicio de sesión. [HandleResponse()] le indica a [JwtBearer] que la respuesta ya está siendo manejada;
- líneas 56–57: los dos componentes de middleware, en este orden: primero se determina quién es el usuario y luego se verifican sus permisos.
El archivo [Controllers/AuthController.cs]:
| using Example25.Auth;
using Microsoft.AspNetCore.Mvc;
namespace Example25.Controllers;
public class AuthController(AuthService auth, IConfiguration configuration) : Controller
{
[HttpGet("/")]
public IActionResult Home() => Redirect("/profile");
[HttpGet("login")]
public IActionResult Form() => View("Login");
[HttpPost("login")]
public IActionResult Login(string? login, string? password)
{
var user = auth.Validate(login, password);
if (user is null)
{
// un mensaje deliberadamente vago: no decimos si es el inicio de sesión o la contraseña
ViewData["Error"] = "Incorrect login or password.";
ViewData["Login"] = login;
return View("Login");
}
// el token, en una cookie que el JavaScript de la página no puede leer
Response.Cookies.Append(AuthService.Cookie, auth.CreateToken(user), new CookieOptions
{
HttpOnly = true,
SameSite = SameSiteMode.Lax,
MaxAge = TimeSpan.FromMinutes(configuration.GetValue<int>("Jwt:DurationMinutes")),
});
return Redirect("/profile");
}
// cerrar sesión cambia el estado del usuario: es un POST
[HttpPost("logout")]
public IActionResult Logout()
{
Response.Cookies.Delete(AuthService.Cookie);
return Redirect("/login");
}
}
|
Comentemos este código:
- líneas 14–23: el inicio de sesión. Si falla, se vuelve a mostrar el formulario con un mensaje deliberadamente vago: decir “este login no existe” ayudaría a un atacante a encontrar logins válidos;
- líneas 26–32: si tiene éxito, el token se almacena en una cookie [HttpOnly]; el [JavaScript] de la página no puede leerla, lo que protege el token si se ejecutara un script malicioso en la página. [SameSite = Lax]: la cookie no se incluye en las solicitudes POST enviadas desde otro sitio, lo que protege contra la falsificación de solicitudes ([CSRF]). La duración de la cookie coincide con la del token;
- líneas 36–40: cerrar sesión elimina la cookie ([Cookies.Delete]). Se trata de un POST: modifica el estado del usuario (vea el ejemplo 21).
El archivo [Controllers/ProfileController.cs]:
| using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Example25.Controllers;
// [Authorize]: reservado a los usuarios autenticados
[Authorize]
public class ProfileController : Controller
{
[HttpGet("profile")]
public IActionResult Profile()
{
// User: el usuario autenticado por el token (HttpContext.User)
return View(User.Claims.Select(c => (c.Type, c.Value)).ToList());
}
}
|
- línea 7: el atributo [[Authorize]], colocado en el controlador, restringe todas sus acciones a los usuarios autenticados. Es un filtro de autorización (vea el capítulo 7). Sin un token válido, desencadena el desafío, lo que produce una redirección a [/login];
- línea 14: [User] (el [HttpContext.User] de la solicitud) es el usuario establecido por [JwtBearer] a partir del token. [User.Claims] es la lista de sus claims; se convierte en una lista de pares (tipo, valor) para la vista.
El archivo [Views/Profile/Profile.cshtml]:
| @model List<(string Type, string Value)>
<h1 class="h3">Hello @User.Identity!.Name</h1>
<p>Your role: <b>@(User.IsInRole("ADMIN") ? "administrator" : "user")</b>.</p>
<p>The content of your token:</p>
<table class="table table-sm w-auto">
@foreach (var (type, value) in Model)
{
<tr><td><code>@type</code></td><td>@value</td></tr>
}
</table>
@* cierre de sesión: un formulario POST reducido a su botón *@
<form method="post" action="/logout">
<button class="btn btn-outline-secondary" type="submit">Log out</button>
</form>
|
- línea 2: la propiedad [User] también es accesible en una vista. El nombre es el claim [name] (vea [NameClaimType]);
- línea 3: [IsInRole] comprueba el claim [role] (vea [RoleClaimType]);
- línea 6: el bucle descompone cada par en dos variables;
- línea 12: cierre de sesión mediante un formulario POST.
El archivo [Views/Auth/Login.cshtml]:
| <h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" value="@ViewData["Login"]" required>
</div>
<div class="mb-3">
<label class="form-label" for="password">Password</label>
<input class="form-control" type="password" id="password" name="password" required>
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
@if (ViewData["Error"] is string error)
{
<div class="alert alert-danger mt-3">@error</div>
}
<p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
|
8.1.1. Ejecución
Sin cookie, la página protegida redirige a la página de inicio de sesión:
| curl -i http://localhost:5000/profile
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /login
|

Una contraseña incorrecta:

Inicio de sesión exitoso, visto con [curl]:
| curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /profile
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3OTAzMzU1MzgsInN1YiI6Im1hcmllIiwibmFtZSI6Ik1hcmllIFDDqWxpc3NpZXIiLCJyb2xlIjoiVVNFUiIsImlhdCI6MTc5MDMzMTkzOCwibmJmIjoxNzkwMzMxOTM4fQ.uAKi5OB-jReuSrQR12_AWdiLR1l6ZLORBYSfHwg99xk; max-age=3600; path=/; samesite=lax; httponly
|
El token consta de tres partes separadas por puntos: un encabezado, el contenido y la firma. Las dos primeras simplemente están codificadas en [base64url]. El encabezado decodificado:
| {"alg":"HS256","typ":"JWT"}
|
(el algoritmo de firma y el tipo de token). El contenido decodificado:
| {
"exp": 1790335538,
"sub": "marie",
"name": "Marie Pélissier",
"role": "USER",
"iat": 1790331938,
"nbf": 1790331938
}
|
Encontramos los claims generados por [CreateToken], más tres campos agregados por [JsonWebTokenHandler]: [exp] (la fecha de expiración), [iat] ([issued at], la fecha de creación) y [nbf] ([not before], la fecha a partir de la cual el token es válido), en segundos desde el 1 de enero de 1970. El token no está cifrado: no contiene ninguna información confidencial. En el navegador, en la URL http://localhost:5000/profile:

Ahora intentemos modificar el token para asignarnos el rol ADMIN: decodificamos el contenido, reemplazamos [USER] por [ADMIN]y lo volvemos a codificar… pero no podemos recalcular la firma sin la clave secreta:
| curl -i -b "token=eyJhbGciOi...(modified content)...(old signature)" http://localhost:5000/profile
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /login
|
La firma ya no coincide con el contenido: el token se rechaza, el usuario no está autenticado y [[Authorize]] redirige a la página de inicio de sesión. Cierre de sesión:
| curl -i -b cookies.txt -X POST http://localhost:5000/logout
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /login
Set-Cookie: token=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/
|
El servidor elimina la cookie restableciéndola —vacía— con una fecha de expiración ya vencida.
8.2. Ejemplo 26: roles
El ejemplo 26 se basa en el ejemplo 25 y agrega una página reservada para el rol ADMIN. Con [ASP.NET Core], casi no hay nada que escribir: el rol es un claim del token y [[Authorize]] sabe verificarlo. El archivo [Controllers/AdminController.cs]:
| using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Example26.Controllers;
// todo el controlador está reservado al rol ADMIN: hay que estar autenticado
// Y tener el claim "role" igual a "ADMIN" (ver RoleClaimType en Program.cs)
[Authorize(Roles = "ADMIN")]
public class AdminController : Controller
{
[HttpGet("admin")]
public IActionResult Admin() => View();
}
|
- línea 8: todo el controlador está reservado para el rol ADMIN. El filtro verifica primero que el usuario esté autenticado (si no: desafío, es decir, la página de inicio de sesión) y luego que tenga el rol exigido (si no: respuesta 403, “acceso denegado”). [Roles = "ADMIN,DOCTOR"] aceptaría cualquiera de estos roles.
El archivo [Program.cs] solo tiene una línea adicional:
| var app = builder.Build();
// 403 (rol insuficiente), 404...: una página de error
app.UseStatusCodePagesWithReExecute("/error/{0}");
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.UseAuthentication(); // ¿quién es? -> HttpContext.User
app.UseAuthorization(); // ¿está permitido? -> [Authorize]
app.MapControllers();
app.Run();
|
- línea 4: la respuesta 403 no tiene contenido; se muestra como una página mediante el controlador [ErrorController] (vea el ejemplo 24).
El usuario [marie] (rol USER) intenta abrir la página de administración desde su perfil:


El mismo intento con [admin]:

Con [curl], vemos un error 403:
| curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
curl -i -b cookies.txt http://localhost:5000/admin
|
| HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Authentication</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
<div class="container py-3" style="max-width: 34rem">
<div class="alert alert-danger">
<h1 class="h4">Error 403</h1>
<p class="mb-0">Access denied: this page is reserved for administrators.</p>
</div>
<p><a href="/profile">Back to the profile</a></p>
</div>
</body>
</html>
|
El caso de estudio tiene tres roles (ADMIN, DOCTOR, USER) y usa exactamente estos atributos: [[Authorize]] en todos los controladores de páginas, [[Authorize(Roles = "ADMIN")]] para la gestión de médicos y clientes, y [[Authorize(Roles = "USER")]] para el área del paciente. Allí se traduce la página 403.
8.3. Ejemplo 27: CAPTCHA y límite de intentos
Una página de inicio de sesión atrae bots: programas que prueban miles de combinaciones de login y contraseña. Dos medidas de protección complementarias:
- un CAPTCHA: una imagen de caracteres distorsionados que un humano lee con facilidad pero que un bot simple no puede descifrar;
- un límite de intentos: tras unos pocos intentos fallidos, la dirección IP se bloquea durante un tiempo;
El ejemplo 27 agrega estas dos medidas al ejemplo 25. El archivo [Auth/CaptchaService.cs]:
| using System.Collections.Concurrent;
namespace Example27.Auth;
// un captcha: su identificador y su imagen (SVG)
public record Captcha(string Id, string Svg);
// singleton: los captchas pendientes se guardan en la memoria del servidor
public class CaptchaService
{
private static readonly TimeSpan Lifetime = TimeSpan.FromMinutes(10);
// identificador -> (respuesta esperada, fecha de vencimiento).
// ConcurrentDictionary: un diccionario utilizable por varias solicitudes simultáneas
private readonly ConcurrentDictionary<string, (string Text, DateTime Expires)> pending = new();
public Captcha Generate()
{
var text = CaptchaDrawing.RandomText(5);
var id = Guid.NewGuid().ToString(); // un identificador aleatorio, imposible de adivinar
pending[id] = (text, DateTime.UtcNow + Lifetime);
return new Captcha(id, CaptchaDrawing.Svg(text));
}
// el captcha se CONSUME en todos los casos: una imagen se usa una sola vez
public bool Check(string? id, string? input)
{
if (id is null || input is null || !pending.TryRemove(id, out var expected))
{
return false;
}
return expected.Expires > DateTime.UtcNow
&& string.Equals(expected.Text, input.Trim(), StringComparison.OrdinalIgnoreCase);
}
}
|
Analicemos este código:
- línea 15: el servidor almacena las respuestas esperadas bajo un identificador aleatorio. La página solo contiene la imagen y el identificador: la respuesta nunca sale del servidor. El servicio es un singleton, utilizado por solicitudes concurrentes: [ConcurrentDictionary] es un diccionario diseñado para este fin;
- líneas 17–22: se elige al azar una cadena de cinco caracteres, se almacena y se dibuja como una imagen. El dibujo está a cargo de la clase [CaptchaDrawing] (archivo [Auth/CaptchaDrawing.cs], tomada del caso de estudio y comentada línea por línea): cada carácter es un conjunto de líneas que se agranda, se inclina y se distorsiona al azar, y la imagen se difumina con tres curvas. Se excluyen los caracteres que se confunden fácilmente (0 y O, 1, I y L);
- líneas 26–33: la verificación consume el CAPTCHA ([TryRemove] lo elimina del diccionario): una imagen se usa una sola vez; un bot no puede reutilizar una solución que ya encontró. Las mayúsculas no cuentan.
El archivo [Auth/LimiterService.cs]:
| namespace Example27.Auth;
// singleton: cuenta los fallos de inicio de sesión de cada dirección IP
public class LimiterService
{
private const int MaxFailures = 3;
private static readonly TimeSpan BlockDuration = TimeSpan.FromMinutes(1);
private class Counter
{
public int Failures;
public DateTime BlockedUntil;
}
private readonly Dictionary<string, Counter> counters = [];
private readonly Lock padlock = new(); // varias solicitudes simultáneas: un acceso a la vez
// el número de segundos de bloqueo restantes (0: no bloqueado)
public int BlockedSeconds(string ip)
{
lock (padlock)
{
if (!counters.TryGetValue(ip, out var c)) return 0;
var remaining = c.BlockedUntil - DateTime.UtcNow;
return remaining > TimeSpan.Zero ? (int)Math.Ceiling(remaining.TotalSeconds) : 0;
}
}
public void Failure(string ip)
{
lock (padlock)
{
if (!counters.TryGetValue(ip, out var c))
{
c = new Counter();
counters[ip] = c;
}
c.Failures++;
if (c.Failures >= MaxFailures)
{
c.BlockedUntil = DateTime.UtcNow + BlockDuration;
c.Failures = 0; // después del bloqueo, se empieza de nuevo desde cero
}
}
}
public void Success(string ip)
{
lock (padlock)
{
counters.Remove(ip);
}
}
}
|
- líneas 6–7: tres intentos fallidos bloquean la dirección IP durante un minuto;
- línea 16: el diccionario de contadores es compartido por todas las solicitudes. La instrucción [lock (padlock) { ... }] garantiza que una sola solicitud a la vez ejecute el bloque: dos fallos simultáneos no pueden perderse (vea [Interlocked], capítulo 6). [Lock] es el tipo de bloqueo a partir de [.NET] 9 y versiones posteriores;
- líneas 19–25: el tiempo de bloqueo restante;
- líneas 29–42: se cuenta un fallo; al tercer fallo, se bloquea la dirección;
- líneas 47–51: un éxito restablece el contador a cero.
El archivo [Controllers/AuthController.cs]:
| using Example27.Auth;
using Microsoft.AspNetCore.Mvc;
namespace Example27.Controllers;
public class AuthController(AuthService auth, CaptchaService captchas, LimiterService limiter,
IConfiguration configuration) : Controller
{
[HttpGet("/")]
public IActionResult Home() => Redirect("/profile");
[HttpGet("login")]
public IActionResult Form() => LoginPage(null, null);
[HttpPost("login")]
public IActionResult Login(string? login, string? password, string? captchaId, string? captcha)
{
// la dirección IP del cliente
var ip = HttpContext.Connection.RemoteIpAddress?.ToString() ?? "?";
// 1. una dirección bloqueada ni siquiera se atiende
var seconds = limiter.BlockedSeconds(ip);
if (seconds > 0)
{
return LoginPage(login, $"Too many attempts: try again in {seconds} s.");
}
// 2. primero el captcha (barato), luego la contraseña (bcrypt, costoso)
if (!captchas.Check(captchaId, captcha))
{
limiter.Failure(ip);
return LoginPage(login, "The image code is incorrect.");
}
var user = auth.Validate(login, password);
if (user is null)
{
limiter.Failure(ip);
return LoginPage(login, "Incorrect login or password.");
}
limiter.Success(ip);
Response.Cookies.Append(AuthService.Cookie, auth.CreateToken(user), new CookieOptions
{
HttpOnly = true,
SameSite = SameSiteMode.Lax,
MaxAge = TimeSpan.FromMinutes(configuration.GetValue<int>("Jwt:DurationMinutes")),
});
return Redirect("/profile");
}
[HttpPost("logout")]
public IActionResult Logout()
{
Response.Cookies.Delete(AuthService.Cookie);
return Redirect("/login");
}
// cada visualización del formulario construye un captcha NUEVO
private ViewResult LoginPage(string? login, string? error)
{
ViewData["Login"] = login;
ViewData["Error"] = error;
return View("Login", captchas.Generate());
}
}
|
Comentemos este código:
- línea 19: la dirección IP del cliente, proporcionada por la conexión de red;
- líneas 22–25: una dirección bloqueada ni siquiera es atendida;
- líneas 28–31: primero se verifica el CAPTCHA y luego la contraseña (una operación [bcrypt] costosa en términos de cómputo) solo si el CAPTCHA es correcto. Un CAPTCHA incorrecto cuenta como un fallo;
- líneas 57–61: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA, que se convierte en el modelo de la vista.
El archivo [Views/Auth/Login.cshtml]:
| @model Captcha
<h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" value="@ViewData["Login"]" required>
</div>
<div class="mb-2">
<label class="form-label" for="password">Password</label>
<input class="form-control" type="password" id="password" name="password" required>
</div>
<div class="mb-3">
<label class="form-label" for="captcha">Copy the code of the image</label>
@* la imagen SVG, construida por el servidor: se inserta sin escapar *@
<div class="mb-1">@Html.Raw(Model.Svg)</div>
@* el identificador del captcha viaja en un campo oculto; la respuesta se queda en el servidor *@
<input type="hidden" name="captchaId" value="@Model.Id">
<input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
@if (ViewData["Error"] is string error)
{
<div class="alert alert-danger mt-3">@error</div>
}
<p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
|
- línea 15: la imagen SVG es texto (XML): se inserta tal cual en la página. [Html.Raw] es legítimo aquí: es HTML generado por el servidor, no una entrada del usuario;
- línea 17: el identificador del CAPTCHA se transmite en un campo oculto; la respuesta, en cambio, permanece en el servidor.
La página de inicio de sesión, en la URL http://localhost:5000/login:

Un CAPTCHA ingresado incorrectamente:

Después de tres intentos fallidos, incluso la contraseña correcta se rechaza durante un minuto:

El caso de estudio aplica estas dos medidas de seguridad a su página de inicio de sesión y al proceso de creación de cuentas, con umbrales ajustables en el archivo [appsettings.json] (sección [Protection]).