8. Authentifizierung und Autorisierung
Bei jeder Anfrage stellen sich zwei getrennte Fragen:
- Wer ist der Benutzer? Das ist die Authentifizierung: Der Benutzer hat sich mit Benutzername und Passwort ausgewiesen, und jede folgende Anfrage muss nachweisen, dass sie von ihm stammt;
- Hat der Benutzer die Berechtigung, auf diese Seite zuzugreifen? Das ist die Autorisierung: In der Fallstudie verwaltet nur ein Benutzer mit der Rolle ADMIN die Ärzte und Kunden.
Da der Server zustandslos ist (Kapitel 6), muss der Identitätsnachweis in jeder Anfrage enthalten sein. Verwendet wird ein JWT-Token ([JSON Web Token]): Nach der Anmeldung erzeugt der Server ein Token, das die Identität des Benutzers enthält, und signiert es mit einem geheimen Schlüssel. Das Token wird in einem Cookie gespeichert; der Browser sendet es mit jeder Anfrage zurück; der Server prüft die Signatur. Der Benutzer kann sein Token lesen, aber nicht ändern: Jede Änderung macht die Signatur ungültig.
[ASP.NET Core] unterscheidet die beiden Fragen klar:
- Die Authentifizierung wird von einer Middleware ([UseAuthentication]) und einem Authentifizierungsschema übernommen: hier das Schema [JwtBearer], bereitgestellt vom [NuGet]-Paket [Microsoft.AspNetCore.Authentication.JwtBearer] . Bei jeder Anfrage sucht es nach einem Token, prüft es und leitet daraus den Benutzer ab, [HttpContext.User];
- Die Autorisierung wird vom Attribut [[Authorize]] übernommen, das von der Middleware [UseAuthorization] geprüft wird: Sie vergleicht die Anforderungen der Action mit dem, was über den Benutzer bekannt ist.
Die Beispiele dieses Kapitels verwenden zwei [NuGet]-Pakete: [Microsoft.AspNetCore.Authentication.JwtBearer] und [BCrypt.Net-Next] (Passwort-Hashing). Sie sind in der Projektdatei deklariert; der Befehl [dotnet build] (oder [dotnet run]) lädt sie bei der ersten Kompilierung von nuget.org herunter: Eine Internetverbindung ist daher erforderlich.
8.1. Beispiel 25: Anmeldung, Token, geschützte Seite
| 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
|
Die Datei [Example25.csproj]:
| <Project Sdk="Microsoft.NET.Sdk.Web">
<ItemGroup>
<!-- Authentifizierung per JWT-Token (Überprüfung des Tokens) -->
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.0" />
<!-- Passwort-Hashing (bcrypt) -->
<PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
</ItemGroup>
</Project>
|
- Zeilen 5–7: die verwendeten [NuGet]-Pakete und ihre Versionen. Die allen Beispielen gemeinsamen Elemente (Version von [.NET] ...) stehen in der Datei [Directory.Build.props] im Ordner [examples].
Die Datei [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
}
}
|
- Zeilen 9–11: ein anwendungsspezifischer Konfigurationsabschnitt: der Schlüssel, mit dem Tokens signiert werden, und ihre Lebensdauer. Wer den Schlüssel kennt, kann gültige Tokens erzeugen: In der Produktion wird er nicht in einer Projektdatei gespeichert, sondern über eine Umgebungsvariable ([Jwt__Secret]) oder einen Secret-Tresor bereitgestellt. Der verwendete Algorithmus (HMAC-SHA256) erfordert einen Schlüssel von mindestens 32 Byte.
Die Datei [Auth/UsersService.cs]:
| namespace Example25.Auth;
public record User(string Login, string Name, string Role, string PasswordHash);
// die Benutzer im Speicher (das nächste Kapitel legt sie in einer Datenbank ab)
public class UsersService
{
private readonly List<User> users =
[
// ein Passwort wird NIE gespeichert, nur sein 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 mit Kostenfaktor 10: 2^10 Berechnungsrunden, bewusst langsam
private static User Create(string login, string name, string role, string password) =>
new(login, name, role, BCrypt.Net.BCrypt.HashPassword(password, 10));
}
|
- Zeile 3: ein Benutzer mit seiner Rolle;
- Zeilen 10–12: Ein Passwort wird nie gespeichert; nur sein Hash wird behalten – ein Fingerabdruck, der von einer Einwegfunktion berechnet wird. Man kann prüfen, ob ein Passwort zu einem Fingerabdruck passt, aber das Passwort nicht aus dem Fingerabdruck wiederherstellen;
- Zeilen 19–20: [BCrypt.Net.BCrypt.HashPassword(password, 10)] berechnet den Hash mit dem Algorithmus [bcrypt]. Die 10 steht für die „Kosten“: [bcrypt] ist absichtlich langsam (2¹⁰ Berechnungsrunden), um davon abzuschrecken, Millionen von Passwörtern auszuprobieren. Zwei Hashes desselben Passworts sind verschieden (es wird ein zufälliges „Salt“ hinzugefügt): [BCrypt.Verify] übernimmt deren Überprüfung.
Die Datei [Auth/AuthService.cs]:
| using System.Text;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
namespace Example25.Auth;
public class AuthService(UsersService users, IConfiguration configuration)
{
// der Name des Cookies, das das Token trägt
public const string Cookie = "token";
// der Schlüssel, der die Tokens signiert, aus appsettings.json gelesen (Abschnitt Jwt)
public static SymmetricSecurityKey Key(IConfiguration configuration) =>
new(Encoding.UTF8.GetBytes(configuration["Jwt:Secret"]!));
// null, wenn der Login unbekannt oder das Passwort falsch ist
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;
}
// das JWT-Token des Benutzers, mit dem geheimen Schlüssel signiert
public string CreateToken(User user)
{
var descriptor = new SecurityTokenDescriptor
{
// der Inhalt des Tokens: die "Claims" (Aussagen über den Benutzer)
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);
}
}
|
Gehen wir diesen Code durch:
- Zeile 10: der Name des Cookies, das das Token trägt;
- Zeilen 13–14: Der Signaturschlüssel, erzeugt aus dem Text von [appsettings.json]. [IConfiguration] bietet Zugriff auf die Konfiguration; ["Jwt:Secret"] bezeichnet die Eigenschaft [Secret] im Abschnitt [Jwt]. Derselbe Schlüssel dient zum Signieren und zum Prüfen der Tokens (symmetrischer Algorithmus);
- Zeilen 17–24: Überprüfung von Benutzername und Passwort;
- Zeilen 33–37: der Inhalt des Tokens, die Claims (Aussagen über den Benutzer). [sub] ([subject]) ist die übliche Bezeichnung für den Bezeichner des Benutzers. Wir nehmen auf, was die Seiten benötigen (Name, Rolle), damit wir nicht bei jeder Anfrage die Datenbank abfragen müssen;
- Zeile 39: das Ablaufdatum des Tokens;
- Zeile 40: der Signaturschlüssel und der Algorithmus;
- Zeile 42: Die Klasse [JsonWebTokenHandler] (Paket [Microsoft.IdentityModel.JsonWebTokens], bereitgestellt von [JwtBearer]) erzeugt das signierte Token.
Die Datei [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>();
// Authentifizierung: ein JWT-Token, bei jeder Anfrage überprüft
builder.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.MapInboundClaims = false; // die Claim-Namen unverändert lassen ("sub", "role"...)
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = AuthService.Key(builder.Configuration), // die Signatur muss von uns stammen
ValidateLifetime = true, // das Token darf nicht abgelaufen sein
ValidateIssuer = false,
ValidateAudience = false,
NameClaimType = "name", // User.Identity.Name
RoleClaimType = "role", // [Authorize(Roles = ...)], User.IsInRole(...)
};
options.Events = new JwtBearerEvents
{
// 1. das Token wird aus dem Cookie gelesen (und nicht aus dem Header Authorization)
OnMessageReceived = context =>
{
context.Token = context.Request.Cookies[AuthService.Cookie];
return Task.CompletedTask;
},
// 2. geschützte Seite ohne gültiges Token: weiter zur Login-Seite
OnChallenge = context =>
{
context.HandleResponse(); // wir erstellen die Antwort selbst (kein 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(); // wer ist es? -> HttpContext.User
app.UseAuthorization(); // ist es erlaubt? -> [Authorize]
app.MapControllers();
app.Run();
|
Kommentieren wir diesen Code:
- Zeilen 16–17: Wir deklarieren das Authentifizierungsschema [JwtBearer] und legen es als Standardschema fest;
- Zeile 19: Standardmäßig benennt [JwtBearer] bestimmte Claims mit langen, von Microsoft-Technologien geerbten Namen um ([role] würde zu [http://schemas.microsoft.com/ws/2008/06/identity/claims/role]). Wir behalten die Namen des Tokens bei;
- Zeilen 20–26: Die Prüfungen, die bei jedem Token durchgeführt werden: die Signatur (mit unserem Schlüssel) und das Ablaufdatum. Unsere Tokens geben weder den Aussteller ([issuer]) noch den Empfänger ([audience]) an, daher prüfen wir sie nicht;
- Zeilen 27–28: welcher Claim den Namen des Benutzers enthält ([User.Identity.Name]) und welcher seine Rolle ([[Authorize(Roles = ...)]], [User.IsInRole(...)]);
- Zeilen 33–36: die Ereignisse von [JwtBearer] ermöglichen es, das Verhalten anzupassen. Standardmäßig sucht es das Token im [Authorization: Bearer ...]-Header der Anfrage: So arbeitet ein [JavaScript]-Client oder eine mobile App. Ein Browser fügt diesen Header nicht von selbst hinzu: Das Token wird aus dem Cookie gelesen;
- Zeilen 39–42: die Challenge tritt auf, wenn eine geschützte Seite ohne gültiges Token angefordert wird. Standardmäßig lautet die Antwort ein 401-Fehler ohne Inhalt: nützlich für einen [JavaScript]-Client, aber verwirrend für einen Benutzer. Der Benutzer wird daher auf die Anmeldeseite umgeleitet. [HandleResponse()] teilt [JwtBearer] mit, dass die Antwort bereits behandelt wird;
- Zeilen 56–57: die beiden Middleware-Komponenten in dieser Reihenfolge: zuerst wird bestimmt, wer der Benutzer ist, dann werden seine Berechtigungen geprüft.
Die Datei [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)
{
// eine bewusst vage Meldung: wir sagen nicht, ob es der Login oder das Passwort ist
ViewData["Error"] = "Incorrect login or password.";
ViewData["Login"] = login;
return View("Login");
}
// das Token in einem Cookie, das das JavaScript der Seite nicht lesen kann
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");
}
// das Abmelden ändert den Zustand des Benutzers: es ist ein POST
[HttpPost("logout")]
public IActionResult Logout()
{
Response.Cookies.Delete(AuthService.Cookie);
return Redirect("/login");
}
}
|
Kommentieren wir diesen Code:
- Zeilen 14–23: die Anmeldung. Schlägt sie fehl, wird das Formular mit einer bewusst vagen Meldung erneut angezeigt: Die Aussage „dieser Login existiert nicht“ würde einem Angreifer helfen, gültige Logins zu finden;
- Zeilen 26–32: Bei Erfolg wird das Token in einem [HttpOnly]-Cookie gespeichert; das [JavaScript] der Seite kann es nicht lesen, was das Token schützt, falls ein schädliches Skript auf der Seite ausgeführt würde. [SameSite = Lax]: Das Cookie wird bei POST-Anfragen von einer anderen Website nicht mitgesendet, was vor Request Forgery schützt ([CSRF]). Die Lebensdauer des Cookies entspricht der des Tokens;
- Zeilen 36–40: Die Abmeldung löscht das Cookie ([Cookies.Delete]). Dies ist ein POST: Er ändert den Zustand des Benutzers (siehe Beispiel 21).
Die Datei [Controllers/ProfileController.cs]:
| using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Example25.Controllers;
// [Authorize]: authentifizierten Benutzern vorbehalten
[Authorize]
public class ProfileController : Controller
{
[HttpGet("profile")]
public IActionResult Profile()
{
// User: der durch das Token authentifizierte Benutzer (HttpContext.User)
return View(User.Claims.Select(c => (c.Type, c.Value)).ToList());
}
}
|
- Zeile 7: Das am Controller gesetzte Attribut [[Authorize]] beschränkt alle seine Aktionen auf authentifizierte Benutzer. Dies ist ein Autorisierungsfilter (siehe Kapitel 7). Ohne gültiges Token löst es die Challenge aus, was zu einer Umleitung nach [/login] führt;
- Zeile 14: [User] (der [HttpContext.User] der Anfrage) ist der Benutzer, den [JwtBearer] anhand des Tokens ermittelt hat. [User.Claims] ist die Liste seiner Claims; sie wird für die View in eine Liste von (Typ, Wert)-Paaren umgewandelt.
Die Datei [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>
@* Abmelden: ein POST-Formular, reduziert auf seinen Button *@
<form method="post" action="/logout">
<button class="btn btn-outline-secondary" type="submit">Log out</button>
</form>
|
- Zeile 2: Die Eigenschaft [User] ist auch in einer View verfügbar. Der Name ist der Claim [name] (siehe [NameClaimType]);
- Zeile 3: [IsInRole] prüft den Claim [role] (siehe [RoleClaimType]);
- Zeile 6: Die Schleife zerlegt jedes Paar in zwei Variablen;
- Zeile 12: Abmeldung über ein POST-Formular.
Die Datei [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. Ausführung
Ohne Cookie leitet die geschützte Seite auf die Anmeldeseite um:
| curl -i http://localhost:5000/profile
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /login
|

Ein falsches Passwort:

Erfolgreiche Anmeldung, gesehen mit [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
|
Das Token besteht aus drei durch Punkte getrennten Teilen: einem Header, dem Inhalt und der Signatur. Die ersten beiden sind lediglich mit [base64url] codiert. Der decodierte Header:
| {"alg":"HS256","typ":"JWT"}
|
(der Signaturalgorithmus und der Tokentyp). Der decodierte Inhalt:
| {
"exp": 1790335538,
"sub": "marie",
"name": "Marie Pélissier",
"role": "USER",
"iat": 1790331938,
"nbf": 1790331938
}
|
Wir finden die von [CreateToken] erzeugten Claims, dazu drei von [JsonWebTokenHandler] hinzugefügte Felder: [exp] (das Ablaufdatum), [iat] ([issued at], das Erstellungsdatum) und [nbf] ([not before], das Datum, ab dem das Token gültig ist), jeweils in Sekunden seit dem 1. Januar 1970. Das Token ist nicht verschlüsselt: Es enthält keine vertraulichen Informationen. Im Browser, unter der URL http://localhost:5000/profile:

Versuchen wir nun, das Token so zu verändern, dass wir uns die Rolle ADMIN zuweisen: Wir decodieren den Inhalt, ersetzen [USER] durch [ADMIN] und codieren ihn neu … aber ohne den geheimen Schlüssel können wir die Signatur nicht neu berechnen:
| curl -i -b "token=eyJhbGciOi...(modified content)...(old signature)" http://localhost:5000/profile
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /login
|
Die Signatur passt nicht mehr zum Inhalt: Das Token wird abgelehnt, der Benutzer ist nicht authentifiziert, und [[Authorize]] leitet auf die Anmeldeseite um. Abmeldung:
| 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=/
|
Der Server löscht das Cookie, indem er es leer und mit einem abgelaufenen Ablaufdatum neu setzt.
8.2. Beispiel 26: Rollen
Beispiel 26 baut auf Beispiel 25 auf und fügt eine Seite hinzu, die der Rolle ADMIN vorbehalten ist. Mit [ASP.NET Core] ist dafür fast nichts zu schreiben: Die Rolle ist ein Claim im Token, und [[Authorize]] kann sie prüfen. Die Datei [Controllers/AdminController.cs]:
| using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Example26.Controllers;
// der gesamte Controller ist der Rolle ADMIN vorbehalten: man muss authentifiziert sein
// UND den Claim "role" mit dem Wert "ADMIN" haben (siehe RoleClaimType in Program.cs)
[Authorize(Roles = "ADMIN")]
public class AdminController : Controller
{
[HttpGet("admin")]
public IActionResult Admin() => View();
}
|
- Zeile 8: Der gesamte Controller ist der Rolle ADMIN vorbehalten. Der Filter prüft zuerst, ob der Benutzer authentifiziert ist (falls nicht: Challenge, d. h. die Anmeldeseite), dann, ob er die verlangte Rolle hat (falls nicht: Antwort 403, „Zugriff verweigert“). [Roles = "ADMIN,DOCTOR"] würde jede dieser beiden Rollen akzeptieren.
Die Datei [Program.cs] enthält nur eine zusätzliche Zeile:
| var app = builder.Build();
// 403 (unzureichende Rolle), 404...: eine Fehlerseite
app.UseStatusCodePagesWithReExecute("/error/{0}");
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.UseAuthentication(); // wer ist es? -> HttpContext.User
app.UseAuthorization(); // ist es erlaubt? -> [Authorize]
app.MapControllers();
app.Run();
|
- Zeile 4: Die 403-Antwort hat keinen Inhalt; sie wird vom Controller [ErrorController] als Seite dargestellt (siehe Beispiel 24).
Der Benutzer [marie] (Rolle USER) versucht, von seinem Profil aus die Verwaltungsseite zu öffnen:


Derselbe Versuch durch [admin]:

Mit [curl] sehen wir einen 403-Fehler:
| 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>
|
Die Fallstudie hat drei Rollen (ADMIN, DOCTOR, USER) und verwendet genau diese Attribute: [[Authorize]] bei allen Seiten-Controllern, [[Authorize(Roles = "ADMIN")]] für die Verwaltung von Ärzten und Klienten und [[Authorize(Roles = "USER")]] für den Patientenbereich. Die 403-Seite ist dort übersetzt.
8.3. Beispiel 27: CAPTCHA und Begrenzung der Versuche
Eine Anmeldeseite zieht Bots an: Programme, die Tausende von Login-/Passwort-Kombinationen ausprobieren. Zwei sich ergänzende Schutzmaßnahmen:
- ein CAPTCHA: ein Bild mit verzerrten Zeichen, das ein Mensch leicht lesen kann, ein einfacher Bot jedoch nicht entziffern kann;
- eine Begrenzung der Versuche: Nach einigen fehlgeschlagenen Versuchen wird die IP-Adresse für eine Weile gesperrt.
Beispiel 27 fügt Beispiel 25 diese beiden Schutzmaßnahmen hinzu. Die Datei [Auth/CaptchaService.cs]:
| using System.Collections.Concurrent;
namespace Example27.Auth;
// ein CAPTCHA: seine Kennung und sein Bild (SVG)
public record Captcha(string Id, string Svg);
// Singleton: die ausstehenden CAPTCHAs werden vom Server im Speicher gehalten
public class CaptchaService
{
private static readonly TimeSpan Lifetime = TimeSpan.FromMinutes(10);
// Kennung -> (erwartete Antwort, Ablaufdatum).
// ConcurrentDictionary: ein Dictionary, das von mehreren gleichzeitigen Anfragen genutzt werden kann
private readonly ConcurrentDictionary<string, (string Text, DateTime Expires)> pending = new();
public Captcha Generate()
{
var text = CaptchaDrawing.RandomText(5);
var id = Guid.NewGuid().ToString(); // eine zufällige, nicht zu erratende Kennung
pending[id] = (text, DateTime.UtcNow + Lifetime);
return new Captcha(id, CaptchaDrawing.Svg(text));
}
// das CAPTCHA wird in jedem Fall VERBRAUCHT: ein Bild wird nur einmal verwendet
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);
}
}
|
Gehen wir diesen Code Schritt für Schritt durch:
- Zeile 15: Die erwarteten Antworten werden vom Server unter einer zufälligen Kennung gespeichert. Die Seite enthält nur das Bild und die Kennung: Die Antwort verlässt den Server nie. Der Service ist ein Singleton, das von gleichzeitigen Anfragen verwendet wird: [ConcurrentDictionary] ist ein Dictionary, das genau dafür gedacht ist;
- Zeilen 17–22: Eine Zeichenkette aus fünf Zeichen wird zufällig ausgewählt, gespeichert und als Bild gezeichnet. Das Zeichnen übernimmt die Klasse [CaptchaDrawing] (Datei [Auth/CaptchaDrawing.cs], aus der Fallstudie übernommen und dort Zeile für Zeile kommentiert): Jedes Zeichen besteht aus einer Menge von Linien, die vergrößert, geneigt und zufällig verzerrt werden, und das Bild wird durch drei Kurven verwischt. Leicht verwechselbare Zeichen (0 und O, 1, I und L) sind ausgeschlossen;
- Zeilen 26–33: Die Überprüfung verbraucht das CAPTCHA ([TryRemove] entfernt es aus dem Dictionary): Ein Bild wird nur einmal verwendet; ein Bot kann eine bereits gefundene Lösung nicht wiederverwenden. Die Groß- und Kleinschreibung spielt keine Rolle.
Die Datei [Auth/LimiterService.cs]:
| namespace Example27.Auth;
// Singleton: zählt die Login-Fehlversuche jeder IP-Adresse
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(); // mehrere gleichzeitige Anfragen: ein Zugriff nach dem anderen
// die Anzahl der verbleibenden Sperrsekunden (0: nicht gesperrt)
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; // nach der Sperre beginnen wir wieder bei null
}
}
}
public void Success(string ip)
{
lock (padlock)
{
counters.Remove(ip);
}
}
}
|
- Zeilen 6–7: Drei fehlgeschlagene Versuche sperren die IP-Adresse für eine Minute;
- Zeile 16: Das Dictionary der Zähler wird von allen Anfragen gemeinsam genutzt. Die Anweisung [lock (padlock) { ... }] stellt sicher, dass immer nur eine Anfrage den Block ausführt: Zwei gleichzeitige Fehlversuche können so nicht verloren gehen (siehe [Interlocked], Kapitel 6). [Lock] ist der Sperrtyp ab [.NET] 9 und in späteren Versionen;
- Zeilen 19–25: die verbleibende Sperrzeit;
- Zeilen 29–42: Ein Fehlversuch wird gezählt; beim dritten Fehlversuch wird die Adresse gesperrt;
- Zeilen 47–51: Ein Erfolg setzt den Zähler auf null zurück.
Die Datei [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)
{
// die IP-Adresse des Clients
var ip = HttpContext.Connection.RemoteIpAddress?.ToString() ?? "?";
// 1. eine gesperrte Adresse wird gar nicht erst beachtet
var seconds = limiter.BlockedSeconds(ip);
if (seconds > 0)
{
return LoginPage(login, $"Too many attempts: try again in {seconds} s.");
}
// 2. zuerst das CAPTCHA (billig), dann das Passwort (bcrypt, teuer)
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");
}
// jede Anzeige des Formulars erzeugt ein NEUES CAPTCHA
private ViewResult LoginPage(string? login, string? error)
{
ViewData["Login"] = login;
ViewData["Error"] = error;
return View("Login", captchas.Generate());
}
}
|
Kommentieren wir diesen Code:
- Zeile 19: die IP-Adresse des Clients, die von der Netzwerkverbindung geliefert wird;
- Zeilen 22–25: Eine gesperrte Adresse wird gar nicht erst angehört;
- Zeilen 28–31: Zuerst wird das CAPTCHA überprüft, dann das Passwort (eine rechenintensive [bcrypt]-Operation), und zwar nur, wenn das CAPTCHA korrekt ist. Ein falsches CAPTCHA zählt als Fehlversuch;
- Zeilen 57–61: Bei jeder Anzeige des Formulars wird ein neues CAPTCHA erzeugt, das zum Modell der View wird.
Die Datei [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>
@* das vom Server erzeugte SVG-Bild: ohne Maskierung eingefügt *@
<div class="mb-1">@Html.Raw(Model.Svg)</div>
@* die Captcha-Kennung reist in einem versteckten Feld; die Antwort bleibt auf dem Server *@
<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>
|
- Zeile 15: Das SVG-Bild ist Text (XML): Es wird unverändert in die Seite eingefügt. [Html.Raw] ist hier zulässig: Es handelt sich um vom Server erzeugtes HTML, nicht um Benutzereingaben;
- Zeile 17: Die CAPTCHA-Kennung wird in einem versteckten Feld übergeben; die Antwort bleibt dagegen auf dem Server.
Die Anmeldeseite unter der URL http://localhost:5000/login:

Ein falsch eingegebenes CAPTCHA:

Nach drei fehlgeschlagenen Versuchen wird selbst das richtige Passwort eine Minute lang abgelehnt:

Die Fallstudie wendet diese beiden Sicherheitsmaßnahmen auf ihre Anmeldeseite und auf die Kontoerstellung an, mit anpassbaren Schwellenwerten in der Datei [appsettings.json] (Abschnitt [Protection]).