Skip to content

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
1
2
3
HTTP/1.1 302 Found
Content-Length: 0
Location: /login

Image

Una contraseña incorrecta:

Image

Inicio de sesión exitoso, visto con [curl]:

curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
1
2
3
4
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:

1
2
3
4
5
6
7
8
{
  "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:

Image

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
1
2
3
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
1
2
3
4
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:

Image

Image

El mismo intento con [admin]:

Image

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:

Image

Un CAPTCHA ingresado incorrectamente:

Image

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

Image

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]).