Skip to content

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 identifiziert, und jede weitere Anfrage muss belegen, 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 Clients.

Da der Server zustandslos ist (Kapitel 6), muss der Identitätsnachweis jeder Anfrage beiliegen. 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 bei 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.

Bei [Spring] werden diese beiden Aufgaben von [Spring Security] übernommen, einem Projekt der [Spring]-Familie, das von [Spring MVC] getrennt ist. [Spring Security] ist eine Kette von Servlet-Filtern (siehe Kapitel 7), die vor [DispatcherServlet] angeordnet ist: Jede Anfrage durchläuft sie, bevor sie [Spring MVC] erreicht.

  • Die Authentifizierung wird von einem Filter übernommen, der in der Anfrage nach einem Token sucht, es prüft und daraus den authentifizierten Benutzer ableitet – ein [Authentication]-Objekt, das im Sicherheitskontext der Anfrage gespeichert wird. Für JWT-Token wird dieser Filter von der Komponente „Resource Server“ ([resource server]) von [Spring Security] bereitgestellt, deren Name vom Protokoll [OAuth2] stammt: Ein Resource Server ist ein Server, der von einem anderen Server (hier von ihm selbst) erzeugte Token akzeptiert;
  • die Autorisierung wird von einem anderen Filter übernommen, der in [Java] geschriebene Regeln für jede URL anwendet („diese Adresse ist öffentlich“, „diese erfordert einen authentifizierten Benutzer“) sowie Annotationen auf Controllern ([@PreAuthorize], Beispiel 26).

Die Beispiele in diesem Kapitel verwenden einen weiteren Starter: [spring-boot-starter-security-oauth2-resource-server]. Er enthält [Spring Security], dessen Komponente „Resource Server“ und die Bibliothek [Nimbus JOSE + JWT], die Token erzeugt und prüft. Das Passwort-Hashing ([bcrypt]) ist Teil von [Spring Security]: Es sind keine weiteren Bibliotheken zu deklarieren. [Maven] lädt diese Bibliotheken bei der ersten Kompilierung herunter; daher ist eine Internetverbindung erforderlich.

8.1. Beispiel 25: Anmeldung, Token, geschützte Seite

25-jwt/
├── src/
│   └── main/
│       ├── java/
│       │   └── example25/
│       │       ├── auth/
│       │       │   ├── AuthService.java
│       │       │   ├── JwtProperties.java
│       │       │   └── UsersService.java
│       │       ├── config/
│       │       │   ├── SecurityConfig.java
│       │       │   └── WebConfig.java
│       │       ├── controllers/
│       │       │   ├── AuthController.java
│       │       │   └── ProfileController.java
│       │       └── Example25Application.java
│       └── resources/
│           ├── templates/
│           │   ├── auth/
│           │   │   └── login.html
│           │   ├── profile/
│           │   │   └── profile.html
│           │   └── layout.html
│           └── application.properties
└── pom.xml

Die Datei [pom.xml]:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>course.springmvc</groupId>
    <artifactId>examples</artifactId>
    <version>1.0</version>
  </parent>
  <artifactId>example25</artifactId>

  <dependencies>
    <!-- die Thymeleaf-Views -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- Spring Security, mit Authentifizierung per JWT-Token (Erzeugung und Prüfung der Token) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security-oauth2-resource-server</artifactId>
    </dependency>
  </dependencies>
</project>
  • Zeilen 15–18: die [Thymeleaf]-Views;
  • Zeilen 20–23: [Spring Security] und die JWT-Token-basierte Authentifizierung. Sobald [Spring Security] im Projekt vorhanden ist, schützt [Spring Boot] standardmäßig alle URLs der Anwendung. Es ist die Konfigurationsklasse [SecurityConfig], die weiter unten gezeigt wird und unsere eigenen Regeln festlegt.

Die Datei [application.properties]:

1
2
3
4
5
6
7
# der Listening-Port des Servers (standardmäßig 8080)
server.port=5000
# die Fehlerantworten von Spring Boot enthalten den Call Stack nicht
spring.web.error.include-stacktrace=never
# der Schlüssel, der die JWT-Token signiert (mindestens 32 Zeichen), und ihre Lebensdauer
jwt.secret=a-secret-key-of-at-least-32-characters-for-example-25
jwt.duration-minutes=60
  • Zeilen 6–7: zwei anwendungsspezifische Eigenschaften: der Schlüssel, der die Token signiert, und ihre Lebensdauer. Wer den Schlüssel kennt, kann gültige Token erzeugen: In der Produktion wird er nicht in einer Projektdatei gespeichert, sondern über eine Umgebungsvariable ([JWT_SECRET], die Vorrang vor der Datei hat) oder einen Secret-Tresor bereitgestellt. Der verwendete Algorithmus (HMAC-SHA256) erfordert einen Schlüssel von mindestens 32 Byte (256 Bit): [Nimbus] weigert sich, mit einem kürzeren Schlüssel zu signieren.

Die Datei [auth/JwtProperties.java]:

1
2
3
4
5
6
7
8
9
package example25.auth;

import org.springframework.boot.context.properties.ConfigurationProperties;

// die [jwt.*]-Properties aus application.properties, in einem Record gespeichert:
// jwt.secret -> secret; jwt.duration-minutes -> durationMinutes
@ConfigurationProperties("jwt")
public record JwtProperties(String secret, int durationMinutes) {
}
  • Zeilen 7–8: Die Annotation [@ConfigurationProperties("jwt")] weist [Spring Boot] an, diesen Record mit den Eigenschaften zu füllen, die mit [jwt.] beginnen: [jwt.secret] kommt in die Komponente [secret], und [jwt.duration-minutes] in die Komponente [durationMinutes] (Bindestriche und Groß-/Kleinschreibung werden ignoriert: Dies ist das flexible Binding von [Spring Boot]). Der Wert [60] wird in [int] umgewandelt; ein Wert, der keine Zahl ist, würde beim Start sofort zum Abbruch der Anwendung mit einer klaren Fehlermeldung führen. Der Record wird zu einem Bean, das wie jeder andere Service per Injektion bezogen wird. Er wird durch die Annotation [@EnableConfigurationProperties] von [SecurityConfig] (unten) deklariert.

Wir hätten jede Eigenschaft über die Annotation [@Value("${jwt.secret}")] lesen können; der Record fasst die Eigenschaften eines einzelnen Themas zusammen und weist jeder einen Typ zu.

Die Datei [auth/UsersService.java]:

package example25.auth;

import java.util.List;
import java.util.Optional;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

// die Benutzer, im Speicher (das nächste Kapitel legt sie in einer Datenbank ab)
@Service
public class UsersService {

    public record User(String login, String name, String role, String passwordHash) {
    }

    private final List<User> users;

    // PasswordEncoder: das Hashing der Passwörter (bcrypt, siehe SecurityConfig)
    public UsersService(PasswordEncoder hashing) {
        // ein Passwort wird NIEMALS gespeichert, nur sein Hash
        users = List.of(
                new User("marie", "Marie Pélissier", "USER", hashing.encode("marie")),
                new User("admin", "Administrator", "ADMIN", hashing.encode("admin")));
    }

    public Optional<User> find(String login) {
        return users.stream().filter(u -> u.login().equals(login)).findFirst();
    }
}
  • Zeilen 13–14: ein Benutzer mit seiner Rolle in Form eines im Service verschachtelten Records;
  • Zeilen 19–24: Ein Passwort wird nie gespeichert; nur sein Hash wird aufbewahrt – ein Hashwert, der von einer Einwegfunktion berechnet wird. Man kann prüfen, ob ein Passwort zu einem Hash passt, aber das Passwort lässt sich aus dem Hash nicht wiederherstellen. Der Service erhält per Injektion einen [PasswordEncoder], die Schnittstelle von [Spring Security] für das Passwort-Hashing, und erzeugt damit die Hashes der beiden Testkonten (Zeile 22);
  • Zeilen 26–28: Die Suche nach einem Benutzer anhand seines Logins liefert ein [Optional<User>] – einen Container, der entweder einen Benutzer enthält oder leer ist. Die Liste wird als Stream ([stream()]) durchlaufen: [filter] behält nur die Elemente, die die Bedingung erfüllen, und [findFirst] liefert das erste (in einem [Optional]).

Die Datei [auth/AuthService.java]:

package example25.auth;

import java.time.Duration;
import java.time.Instant;
import java.util.Optional;

import org.springframework.http.ResponseCookie;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.jose.jws.MacAlgorithm;
import org.springframework.security.oauth2.jwt.JwsHeader;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
import org.springframework.stereotype.Service;

import example25.auth.UsersService.User;

@Service
public class AuthService {

    // der Name des Cookies, das das Token trägt
    public static final String COOKIE = "token";

    private final UsersService users;
    private final PasswordEncoder hashing;
    private final JwtEncoder encoder;
    private final JwtProperties properties;

    public AuthService(UsersService users, PasswordEncoder hashing, JwtEncoder encoder,
            JwtProperties properties) {
        this.users = users;
        this.hashing = hashing;
        this.encoder = encoder;
        this.properties = properties;
    }

    // der Benutzer oder "nichts", wenn der Login unbekannt oder das Passwort falsch ist
    public Optional<User> validate(String login, String password) {
        if (login == null || password == null) {
            return Optional.empty();
        }
        return users.find(login).filter(u -> hashing.matches(password, u.passwordHash()));
    }

    // das JWT-Token des Benutzers, mit dem geheimen Schlüssel signiert
    public String createToken(User user) {
        Instant now = Instant.now();
        // der Inhalt des Tokens: die "Claims" (Aussagen über den Benutzer)
        JwtClaimsSet claims = JwtClaimsSet.builder()
                .subject(user.login())
                .claim("name", user.name())
                .claim("role", user.role())
                .issuedAt(now)
                .expiresAt(now.plus(duration()))
                .build();
        // der Header: der Signaturalgorithmus (HMAC-SHA256)
        JwsHeader header = JwsHeader.with(MacAlgorithm.HS256).build();
        return encoder.encode(JwtEncoderParameters.from(header, claims)).getTokenValue();
    }

    // das Cookie, das das Token trägt: das JavaScript der Seite kann es nicht lesen
    public ResponseCookie cookie(String token) {
        return ResponseCookie.from(COOKIE, token).path("/").httpOnly(true).sameSite("Lax").maxAge(duration()).build();
    }

    private Duration duration() {
        return Duration.ofMinutes(properties.durationMinutes());
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeile 22: der Name des Cookies, das das Token trägt;
  • Zeilen 29–35: Der Service erhält über seinen Konstruktor den Benutzer-Service, den Passwort-Encoder, den Token-Encoder [JwtEncoder], und die Eigenschaften [jwt.*]. Diese letzten drei Beans werden in [SecurityConfig] deklariert;
  • Zeilen 38–43: Anmeldung und Passwortprüfung. [Optional.filter] leert den Container, wenn die Bedingung falsch ist: Das Ergebnis enthält den Benutzer nur, wenn das Login existiert und wenn [hashing.matches(password, hash)] das Passwort erkennt;
  • Zeilen 49–55: der Inhalt des Tokens, die Claims (Aussagen über den Benutzer). [subject] (der Claim [sub]) ist der übliche Name für die Kennung des Benutzers. Wir nehmen hier auf, was die Seiten benötigen (Name, Rolle), um nicht bei jeder Anfrage die Datenbank abfragen zu müssen. [issuedAt] und [expiresAt] liefern die Claims [iat] (Erstellungsdatum) und [exp] (Ablaufdatum);
  • Zeile 57: der Header des Tokens, der den Signaturalgorithmus angibt: HMAC-SHA256, bezeichnet als [HS256];
  • Zeile 58: Der Encoder erzeugt das signierte Token; [getTokenValue()] wandelt es in Textform um;
  • Zeilen 62–64: das Cookie, das das Token trägt, erzeugt von der Klasse [ResponseCookie] aus [Spring]: [httpOnly(true)] verhindert, dass das [JavaScript] der Seite es liest, was das Token schützt, falls ein bösartiges Skript auf der Seite ausgeführt würde; [sameSite("Lax")] verhindert, dass der Browser es in POST-Anfragen einbezieht, die von einer anderen Website gesendet werden (siehe unten, der [CSRF]-Schutz); [maxAge] legt die Lebensdauer des Cookies passend zur Lebensdauer des Tokens fest.

Die Datei [config/SecurityConfig.java] ist das Herzstück dieses Beispiels. Ihr erster Teil deklariert die für die Sicherheit erforderlichen Beans:

package example25.config;

import java.nio.charset.StandardCharsets;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.ResponseCookie;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.jose.jws.MacAlgorithm;
import org.springframework.security.oauth2.jwt.JwtDecoder;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
import org.springframework.security.oauth2.server.resource.web.BearerTokenResolver;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.util.WebUtils;

import example25.auth.AuthService;
import example25.auth.JwtProperties;
import jakarta.servlet.http.Cookie;

// die Konfiguration von Spring Security
@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {

    // der Schlüssel, der die Token signiert und prüft (symmetrischer Algorithmus HMAC-SHA256)
    @Bean
    public SecretKey jwtKey(JwtProperties properties) {
        return new SecretKeySpec(properties.secret().getBytes(StandardCharsets.UTF_8), "HmacSHA256");
    }

    // die Erzeugung der Token (Nimbus-Bibliothek, von Spring Security mitgebracht)
    @Bean
    public JwtEncoder jwtEncoder(SecretKey key) {
        return NimbusJwtEncoder.withSecretKey(key).algorithm(MacAlgorithm.HS256).build();
    }

    // die Prüfung der Token: Signatur und Ablaufdatum
    @Bean
    public JwtDecoder jwtDecoder(SecretKey key) {
        return NimbusJwtDecoder.withSecretKey(key).macAlgorithm(MacAlgorithm.HS256).build();
    }

    // das Hashing der Passwörter: bcrypt, mit einem Cost-Faktor von 10
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(10);
    }
  • Zeile 33: eine Konfigurationsklasse, deren mit [@Bean] annotierte Methoden Beans erstellen (siehe Beispiel 06);
  • Zeile 34: Registrierung des Records [JwtProperties] als Bean, gefüllt aus [application.properties];
  • Zeilen 38–41: der Signaturschlüssel, erzeugt aus dem Text der Eigenschaft [jwt.secret]. Derselbe Schlüssel wird zum Signieren und zum Prüfen der Token verwendet: Der Algorithmus ist symmetrisch. Eine Methode mit [@Bean] kann andere Beans als Parameter akzeptieren: hier die Eigenschaften [jwt.*];
  • Zeilen 44–47: der Token-Encoder, der mit dem Schlüssel signiert. [NimbusJwtEncoder] stützt sich auf die Bibliothek [Nimbus];
  • Zeilen 50–53: der Decoder, der jedes empfangene Token prüft: zuerst die Signatur (mit demselben Schlüssel), dann das Ablaufdatum (mit einer Toleranz von 60 Sekunden für nicht synchrone Uhren). Der Authentifizierungsfilter verwendet ihn für jede Anfrage, die ein Token enthält;
  • Zeilen 56–59: Passwort-Hashing mit dem Algorithmus [bcrypt] mit einem „Cost“-Faktor von 10: [bcrypt] ist absichtlich langsam (2¹⁰ Rechenzyklen), um davon abzuhalten, Millionen von Passwörtern auszuprobieren. Zwei Hashes desselben Passworts sind verschieden (ein zufälliger „Salt“ wird hinzugefügt): [matches] übernimmt ihre Prüfung.

Der zweite Teil beschreibt die Kette der Sicherheitsfilter:

    // die Kette der Sicherheitsfilter: wer worauf zugreifen darf und wie
    // der Benutzer erkannt wird
    @Bean
    public SecurityFilterChain securityFilters(HttpSecurity http) throws Exception {
        http
                // 1. die Zugriffsregeln, der Reihe nach geprüft
                .authorizeHttpRequests(access -> access
                        .requestMatchers("/", "/login", "/error", "/bootstrap/**").permitAll()
                        .anyRequest().authenticated())
                // 2. Authentifizierung per JWT-Token (OAuth2 "Resource Server")
                .oauth2ResourceServer(jwt -> jwt
                        .bearerTokenResolver(tokenFromCookie())
                        .authenticationEntryPoint(toLogin())
                        .jwt(config -> config.jwtAuthenticationConverter(converter())))
                // 3. geschützte Seite ohne Token angefordert: weiter zur Login-Seite
                .exceptionHandling(errors -> errors.authenticationEntryPoint(toLogin()))
                // 4. Abmeldung (POST /logout): das Cookie löschen, dann weiter zu /login
                .logout(logout -> logout.logoutUrl("/logout").deleteCookies(AuthService.COOKIE)
                        .logoutSuccessUrl("/login"))
                // 5. der Server ist zustandslos: keine HTTP-Session
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                // 6. kein Anti-CSRF-Token: das Cookie mit SameSite=Lax schützt bereits
                // die POST-Anfragen, die von anderen Websites kommen
                .csrf(csrf -> csrf.disable());
        return http.build();
    }

    // das Token wird aus dem Cookie gelesen (und nicht aus dem Header Authorization)
    private static BearerTokenResolver tokenFromCookie() {
        return request -> {
            Cookie cookie = WebUtils.getCookie(request, AuthService.COOKIE);
            return cookie == null ? null : cookie.getValue();
        };
    }

    // kein authentifizierter Benutzer (kein Token, ungültiges oder abgelaufenes Token):
    // wir löschen das eventuelle Cookie und leiten auf die Login-Seite um
    private static AuthenticationEntryPoint toLogin() {
        return (request, response, exception) -> {
            if (WebUtils.getCookie(request, AuthService.COOKIE) != null) {
                response.addHeader("Set-Cookie", ResponseCookie.from(AuthService.COOKIE, "").path("/").maxAge(0).build().toString());
            }
            response.sendRedirect("/login");
        };
    }

    // vom Token zum authentifizierten Benutzer: der Claim [name] ist sein Name, der
    // Claim [role] seine Rolle; Spring Security schreibt die Rollen mit dem Präfix ROLE_
    private static JwtAuthenticationConverter converter() {
        JwtGrantedAuthoritiesConverter roles = new JwtGrantedAuthoritiesConverter();
        roles.setAuthoritiesClaimName("role");
        roles.setAuthorityPrefix("ROLE_");
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(roles);
        converter.setPrincipalClaimName("name");
        return converter;
    }
}

Zerlegen wir diesen Code:

  • Zeilen 4–5: ein Bean vom Typ [SecurityFilterChain]: die Kette der Sicherheitsfilter. [Spring Boot] stellt ein [HttpSecurity]-Objekt bereit, das wir Methode für Methode konfigurieren, bevor wir die Kette erstellen (Zeile 26). Jede Methode erhält ein Lambda, das einen Teil der Einstellungen konfiguriert;
  • Zeilen 8–10: die Zugriffsregeln für URLs, in dieser Reihenfolge geprüft: [/], [/login], [/error] (die Fehlerseite von [Spring Boot]) und die Dateien von [Bootstrap] sind öffentlich ([permitAll()]); jede andere URL ([anyRequest()]) erfordert einen authentifizierten Benutzer. Die Seite [/profile] ist somit geschützt, ohne dass in ihrem Controller etwas geschrieben werden muss;
  • Zeilen 12–15: tokenbasierte Authentifizierung mit JWT. Standardmäßig sucht der Resource Server 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: Ihm wird gesagt, das Token aus dem Cookie zu holen (Zeile 13). Zeile 15 ändert die Art, wie das Token einem Benutzer zugeordnet wird (siehe Zeilen 50–58);
  • Zeilen 14 und 17: der Authentication Entry Point ([authentication entry point]) wird aufgerufen, wenn eine geschützte Seite ohne authentifizierten Benutzer angefordert wird. Standardmäßig ist die Antwort ein Fehler 401 ohne Inhalt: nützlich für einen [JavaScript]-Client, aber verwirrend für einen Benutzer. Der Benutzer wird zur Anmeldeseite umgeleitet. Dies wird zweimal deklariert: Der Resource-Server-Filter ruft direkt seinen eigenen Entry Point auf, wenn die Anfrage ein Token enthält, das er ablehnt (Zeile 14); Zeile 17 deckt den Fall ab, dass eine geschützte Seite ohne Token angefordert wird;
  • Zeilen 19–20: Die Abmeldung übernimmt [Spring Security] selbst über einen Filter ([LogoutFilter]), der [POST /logout] abfängt: Er löscht das Token-Cookie ([deleteCookies]) und leitet nach [/login] um. Es ist keine Controller-Action erforderlich;
  • Zeile 22: [STATELESS]: [Spring Security] erstellt keine (HTTP-)Session (siehe Kapitel 6) und verwendet sie nicht, um den Benutzer zu behalten. Der Benutzer wird bei jeder Anfrage ausschließlich anhand des Tokens erkannt;
  • Zeile 25: Der [CSRF]-Schutz ([Cross-Site Request Forgery], websiteübergreifende Anfragefälschung) ist deaktiviert. Ein [CSRF]-Angriff besteht darin, dass eine bösartige Website den Browser des Opfers dazu bringt, ein POST-Formular an unsere Website zu senden: Der Browser würde das Cookie mitsenden, und die Anfrage wäre authentifiziert. Standardmäßig verlangt [Spring Security] in jedem POST-Formular ein Anti-CSRF-Token – ein verstecktes Feld, das die bösartige Website nicht kennen kann. Hier genügt das Cookie [SameSite=Lax]: Der Browser sendet es nicht in einer POST-Anfrage mit, die von einer anderen Website stammt, sodass diese Anfrage ohne authentifizierten Benutzer eintrifft. Allerdings darf keine GET-Anfrage mit dem Cookie irgendwelche Daten ändern (siehe Beispiel 21): Ein [Lax]-Cookie begleitet Links, die von anderen Websites kommen;
  • Zeilen 30–35: der Token-Resolver ([BearerTokenResolver]): eine Schnittstelle mit einer einzigen Methode, hier als Lambda geschrieben, die das Token der Anfrage zurückgibt oder [null]. [WebUtils.getCookie] sucht ein Cookie anhand seines Namens;
  • Zeilen 39–46: Der Entry Point: eine Weiterleitung nach [/login] (Zeile 44). Enthielt die Anfrage ein [token]-Cookie, bedeutet das, dass das Token ungültig (ungültige Signatur) oder abgelaufen ist: Das Cookie wird gelöscht, indem es mit einem leeren Wert und einer Lebensdauer von null neu gesetzt wird (Zeilen 41–43). Ohne diesen Schritt würde der Browser das abgelehnte Token mit der Anfrage [GET /login] erneut senden, die der Filter seinerseits ablehnen würde – es käme zu einer Weiterleitungsschleife;
  • Zeilen 50–58: vom Token zum authentifizierten Benutzer. Für [Spring Security] sind die Berechtigungen eines Benutzers Authorities ([authorities]): einfache Zeichenketten. Standardmäßig liest der Resource Server sie aus dem Claim [scope] des Tokens, mit dem Präfix [SCOPE_]. Hier werden sie aus dem Claim [role] gelesen (Zeile 52), mit dem Präfix [ROLE_] (Zeile 53), das [Spring Security] für eine Rolle erwartet: Die Rolle [USER] des Tokens wird zur Authority [ROLE_USER]. Zeile 56 legt fest, dass der Benutzername ([Authentication.getName()]) der Claim [name] ist, nicht [sub].

Die Filter, die [Spring Security] in die Kette eingefügt hat, werden beim Start auf der Konsole ausgegeben, wenn das Log-Level [DEBUG] für die Klasse [DefaultSecurityFilterChain] angefordert wird:

../mvnw spring-boot:run -Dspring-boot.run.arguments=--logging.level.org.springframework.security.web.DefaultSecurityFilterChain=debug
... DEBUG ... o.s.s.web.DefaultSecurityFilterChain : Will secure any request with filters: DisableEncodeUrlFilter, WebAsyncManagerIntegrationFilter, SecurityContextHolderFilter, HeaderWriterFilter, LogoutFilter, OAuth2ProtectedResourceMetadataFilter, BearerTokenAuthenticationFilter, RequestCacheAwareFilter, SecurityContextHolderAwareRequestFilter, AnonymousAuthenticationFilter, SessionManagementFilter, ExceptionTranslationFilter, AuthorizationFilter

Insbesondere lassen sich folgende erkennen:

  • [HeaderWriterFilter], der jeder Antwort Sicherheits-Header hinzufügt ([X-Content-Type-Options: nosniff], [X-Frame-Options: DENY], [Cache-Control: no-cache, no-store...]): Diese sind in den Antworten dieses Kapitels nicht enthalten;
  • [LogoutFilter], der [/logout] verarbeitet;
  • [BearerTokenAuthenticationFilter], der Resource-Server-Filter: Er liest das Token (mit unserem Resolver), prüft es (mit dem Decoder) und legt den authentifizierten Benutzer im Sicherheitskontext ab;
  • [AnonymousAuthenticationFilter]: Ohne Token ist der Benutzer „anonym“;
  • [ExceptionTranslationFilter], der Zugriffsverweigerungen in HTTP-Antworten umwandelt: Entry Point für einen anonymen Benutzer, Fehler 403 für einen authentifizierten Benutzer (Beispiel 26);
  • [AuthorizationFilter], der letzte, der die Regeln in [authorizeHttpRequests] anwendet.

Die Datei [controllers/AuthController.java]:

package example25.controllers;

import java.util.Optional;

import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import example25.auth.AuthService;
import example25.auth.UsersService.User;
import jakarta.servlet.http.HttpServletResponse;

@Controller
public class AuthController {

    private final AuthService auth;

    public AuthController(AuthService auth) {
        this.auth = auth;
    }

    @GetMapping("/")
    public String home() {
        return "redirect:/profile";
    }

    @GetMapping("/login")
    public String form() {
        return "auth/login";
    }

    @PostMapping("/login")
    public String login(@RequestParam(required = false) String login,
            @RequestParam(required = false) String password, HttpServletResponse response, Model model) {
        Optional<User> user = auth.validate(login, password);
        if (user.isEmpty()) {
            // eine bewusst vage Meldung: wir sagen nicht, ob es der Login oder das Passwort ist
            model.addAttribute("error", "Incorrect login or password.");
            model.addAttribute("login", login);
            return "auth/login";
        }
        // das Token, in einem Cookie
        response.addHeader(HttpHeaders.SET_COOKIE, auth.cookie(auth.createToken(user.get())).toString());
        return "redirect:/profile";
    }
}

Zerlegen wir diesen Code:

  • Zeilen 35–44: die Anmeldung. Die Parameter sind optional ([required = false]): Ein fehlender Parameter ist standardmäßig [null], und [AuthService.validate] lehnt ihn ab. Schlägt die Anmeldung fehl, wird das Formular mit einer bewusst vagen Meldung erneut angezeigt: Die Angabe „dieses Login existiert nicht“ würde einem Angreifer helfen, gültige Logins zu finden;
  • Zeile 46: Bei Erfolg wird das Cookie der Antwort als Header [Set-Cookie] hinzugefügt, vor der Weiterleitung zum Profil;
  • Es gibt keine [/logout]-Action: Die Abmeldung wird vom Filter [LogoutFilter] übernommen, noch bevor die Anfrage [Spring MVC] erreicht.

Die Datei [controllers/ProfileController.java]:

package example25.controllers;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

// authentifizierten Benutzern vorbehalten: siehe SecurityConfig (anyRequest().authenticated())
@Controller
public class ProfileController {

    // Authentication: der durch das Token authentifizierte Benutzer;
    // @AuthenticationPrincipal Jwt: das Token selbst, bereits geprüft
    @GetMapping("/profile")
    public String profile(Authentication user, @AuthenticationPrincipal Jwt token, Model model) {
        model.addAttribute("name", user.getName());
        model.addAttribute("admin", user.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN")));
        model.addAttribute("claims", token.getClaims());
        return "profile/profile";
    }
}
  • Zeile 10: Keine Sicherheitsannotation am Controller: Die Regel [anyRequest().authenticated()] aus [SecurityConfig] schützt [/profile] bereits;
  • Zeile 17: Eine Action kann den authentifizierten Benutzer als Parameter vom Typ [Authentication] erhalten, der vom Resource-Server-Filter im Sicherheitskontext abgelegt wurde. Die Annotation [@AuthenticationPrincipal] ermöglicht den Zugriff auf den Principal dieses Benutzers: Bei der Authentifizierung über JWT ist dies das Token selbst (Typ [Jwt]), das bereits geprüft wurde;
  • Zeile 18: der Name des Benutzers, der Claim [name] (siehe [setPrincipalClaimName]);
  • Zeilen 19–20: Ist der Benutzer Administrator? Wir prüfen, ob die Authority [ROLE_ADMIN] unter den Authorities des Benutzers vorhanden ist;
  • Zeile 21: die Claims des Tokens in Form eines Dictionarys ([Map<String, Object>]).

Die Datei [templates/profile/profile.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3" th:text="|Hello ${name}|">Hello</h1>
  <p>Your role: <b th:text="${admin} ? 'administrator' : 'user'">user</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    <!--/* eine Schleife über ein Dictionary: jedes Element hat einen Schlüssel und einen Wert */-->
    <tr th:each="claim : ${claims}"><td><code th:text="${claim.key}">sub</code></td><td th:text="${claim.value}">marie</td></tr>
  </table>
  <!--/* Abmeldung: ein POST-Formular, das auf seinen Button reduziert ist */-->
  <form method="post" action="/logout">
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
</main>
</body>
</html>
  • Zeile 10: [th:each] durchläuft auch ein Dictionary: Jedes Element hat einen Schlüssel ([claim.key]) und einen Wert ([claim.value]);
  • Zeilen 13–15: Die Abmeldung über ein POST-Formular, reduziert auf seine Schaltfläche.

Die Datei [templates/auth/login.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <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" th:value="${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>
  <div class="alert alert-danger mt-3" th:if="${error != null}" th:text="${error}">error</div>
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
</main>
</body>
</html>
  • Zeile 9: der eingegebene Benutzername wird nach einer fehlgeschlagenen Anmeldung erneut angezeigt; das Passwort wird nie erneut angezeigt;
  • Zeile 17: die Fehlermeldung, falls vorhanden.

Das Template [templates/layout.html] und die Klasse [config/WebConfig.java], die die Dateien von [Bootstrap] unter der URL [/bootstrap/...] bereitstellen, sind dieselben wie in den vorherigen Beispielen (siehe Beispiel 15 und Kapitel 1).

8.1.1. Ausführung

Ohne Cookie leitet die geschützte Seite zur Anmeldeseite um:

curl -i http://localhost:5000/profile
1
2
3
HTTP/1.1 302
Location: http://localhost:5000/login
Content-Length: 0

([Tomcat] gibt den Text [Found], der üblicherweise auf den Code 302 folgt, nicht aus: Er ist optional.)

Image

Ein falsches Passwort:

Image

Erfolgreiche Anmeldung, gesehen mit [curl]:

curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
1
2
3
4
HTTP/1.1 302
Set-Cookie: token=eyJraWQiOiJLQzBjVllOZXdUWWFTY1FWM21EV1ZEbFQ0bDZWYmFfUTNSNjB6cmNtWmQ0IiwiYWxnIjoiSFMyNTYifQ.eyJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInN1YiI6Im1hcmllIiwicm9sZSI6IlVTRVIiLCJleHAiOjE3OTAzNTgzNTYsImlhdCI6MTc5MDM1NDc1Nn0.ZsCOrkYPuZFYu2xPtIx3JGpKBQCOJP9dqF8fzkwpLmo; Path=/; Max-Age=3600; Expires=Fri, 25 Sep 2026 17:45:56 GMT; HttpOnly; SameSite=Lax
Location: http://localhost:5000/profile
Content-Length: 0

Das Token besteht aus drei durch Punkte getrennten Teilen: einem Header, dem Inhalt und der Signatur. Die ersten beiden sind lediglich als [base64url] kodiert. Der dekodierte Header:

{"kid":"KC0cVYNewTYaScQV3mDWVDlT4l6Vba_Q3R60zrcmZd4","alg":"HS256"}

Er enthält den Signaturalgorithmus ([alg]) und eine Schlüsselkennung ([kid], [key id]): Wenn ein Server mehrere Schlüssel verwendet, sagt ihm die [kid] , welcher Schlüssel das Token signiert hat. [NimbusJwtEncoder] berechnet sie selbst aus dem Schlüssel (es handelt sich um den SHA-256-Fingerabdruck des Schlüssels gemäß dem Standard [JWK Thumbprint]): Sie verrät nichts über den Schlüssel. Der dekodierte Inhalt:

1
2
3
4
5
6
7
{
  "name": "Marie Pélissier",
  "sub": "marie",
  "role": "USER",
  "exp": 1790358356,
  "iat": 1790354756
}

Wir finden die von [createToken] erzeugten Claims wieder. Die Datumsangaben [exp] und [iat] sind in Sekunden seit dem 1. Januar 1970 angegeben. Das Token ist nicht verschlüsselt: Es enthält nichts Geheimes. Im Browser unter der URL http://localhost:5000/profile:

Image

Auf der Seite werden die Datumsangaben [exp] und [iat] im Format ISO 8601 angezeigt: Der Decoder hat sie in [Instant]-Objekte umgewandelt (ein Zeitpunkt in Weltzeit, daher das abschließende [Z]). Wir sehen, dass das Token eine Stunde lang gültig ist.

Versuchen wir nun, das Token zu ändern, um uns die Rolle ADMIN zuzuweisen: Wir dekodieren den Inhalt, ersetzen [USER] durch [ADMIN] und kodieren ihn neu ... aber ohne den geheimen Schlüssel können wir die Signatur nicht neu berechnen:

curl -i -b "token=eyJraWQiOi...(modified content)...(old signature)" http://localhost:5000/profile
1
2
3
4
HTTP/1.1 302
Set-Cookie: token=; Path=/; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT
Location: http://localhost:5000/login
Content-Length: 0

Die Signatur passt nicht mehr zum Inhalt: Der Decoder lehnt das Token ab, der Filter ruft den Entry Point auf, der das Cookie löscht und zur Anmeldeseite umleitet. Abmeldung:

curl -i -b cookies.txt -X POST http://localhost:5000/logout
1
2
3
4
HTTP/1.1 302
Set-Cookie: token=; Expires=Thu, 01 Jan 1970 00:00:10 GMT; Path=/
Location: http://localhost:5000/login
Content-Length: 0

Der [LogoutFilter] löscht das Cookie, indem er es – leer – mit einem abgelaufenen Ablaufdatum neu setzt. Beachten Sie: Da der [CSRF]-Schutz deaktiviert ist, akzeptiert [Spring Security] auch die Abmeldung über ein GET ([curl -i http://localhost:5000/logout] liefert dieselbe Antwort): Das ist hier unbedenklich (im schlimmsten Fall meldet ein bösartiger Link den Benutzer ab), aber unsere Seiten melden Benutzer stets per POST ab.

8.2. Beispiel 26: Rollen

Beispiel 26 baut auf Beispiel 25 auf und fügt eine Seite hinzu, die der Rolle ADMIN vorbehalten ist. Die Rolle ist bereits eine Authority des authentifizierten Benutzers ([ROLE_ADMIN]): Sie muss nur noch verlangt werden. Die Datei [controllers/AdminController.java]:

package example26.controllers;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

// der gesamte Controller ist der Rolle ADMIN vorbehalten: man muss authentifiziert sein UND
// die Rolle ADMIN haben (der Claim "role" des Tokens, siehe SecurityConfig)
@Controller
@PreAuthorize("hasRole('ADMIN')")
public class AdminController {

    @GetMapping("/admin")
    public String admin(Authentication user, Model model) {
        model.addAttribute("name", user.getName());
        return "admin/admin";
    }
}
  • Zeile 12: Die Annotation [@PreAuthorize] legt eine Bedingung fest, die vor jedem Aufruf einer Action des Controllers geprüft wird. Die Bedingung ist ein Ausdruck in der Sprache [SpEL] ([Spring Expression Language]): [hasRole('ADMIN')] ist wahr, wenn der Benutzer die Authority [ROLE_ADMIN] besitzt (das Präfix [ROLE_] wird von [hasRole] hinzugefügt). Ein anonymer Benutzer wird zunächst zur Anmeldeseite umgeleitet (Entry Point); ein authentifizierter Benutzer ohne diese Rolle erhält eine Antwort 403, „Access Denied“. [hasAnyRole('ADMIN', 'DOCTOR')] würde jede dieser beiden Rollen akzeptieren.

Damit [@PreAuthorize] berücksichtigt wird, hat die Klasse [SecurityConfig] eine zusätzliche Annotation:

1
2
3
4
5
6
// die Konfiguration von Spring Security.
// @EnableMethodSecurity: aktiviert die Annotationen @PreAuthorize der Controller
@Configuration
@EnableMethodSecurity
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {
  • Zeile 4: [@EnableMethodSecurity] aktiviert die Methodensicherheit. [Spring] umhüllt dann jedes Bean, dessen Methode [@PreAuthorize] trägt, mit einem Proxy: einem Vermittlerobjekt, das Aufrufe im Namen des Beans entgegennimmt, die Bedingung prüft und dann die eigentliche Methode aufruft oder eine [AccessDeniedException] auslöst. Auf diesen Proxy-Mechanismus kommen wir im Zusammenhang mit Transaktionen im nächsten Kapitel zurück.

Die Filterkette hat sich an zwei Stellen geändert:

1
2
3
4
5
6
7
8
9
                .oauth2ResourceServer(jwt -> jwt
                        .bearerTokenResolver(tokenFromCookie())
                        .authenticationEntryPoint(toLogin())
                        .accessDeniedHandler(accessDenied())
                        .jwt(config -> config.jwtAuthenticationConverter(converter())))
                // 3. geschützte Seite ohne Token angefordert: weiter zur Login-Seite;
                // unzureichende Rolle: eine 403-Antwort, vom ErrorPageController in eine Seite umgewandelt
                .exceptionHandling(errors -> errors.authenticationEntryPoint(toLogin())
                        .accessDeniedHandler(accessDenied()))
  • Zeilen 4 und 9: der Access-Denied-Handler ([access denied handler]). Die von [@PreAuthorize] ausgelöste Exception wird über [Spring MVC] an den Filter [ExceptionTranslationFilter] weitergereicht, der sie an diesen Handler übergibt. Der Handler des Resource Servers würde eine Antwort 403 ohne Inhalt zurückgeben, einschließlich eines [WWW-Authenticate]-Headers, der für einen [JavaScript]-Client bestimmt ist. Wie beim Entry Point wird er an zwei Stellen ersetzt.

Der Handler selbst, am Ende der Datei:

1
2
3
4
    // unzureichende Rolle: eine Fehlerantwort 403, die der Server an /error weiterleitet
    private static AccessDeniedHandler accessDenied() {
        return (request, response, exception) -> response.sendError(HttpServletResponse.SC_FORBIDDEN);
    }
  • Zeilen 2–4: Unser Handler verwendet einfach [sendError(403)]. Der Server [Tomcat] leitet die Anfrage dann an die URL [/error] weiter (siehe Beispiel 24), also an den Fehler-Handler. Deshalb steht [/error] unter den öffentlichen URLs: Die weitergeleitete Anfrage durchläuft ebenfalls die Filterkette.

Die Datei [controllers/ErrorPageController.java]:

package example26.controllers;

import org.springframework.boot.webmvc.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

// die Seite der Fehlerantworten (403, 404 ...): siehe Beispiel 24
@Controller
public class ErrorPageController implements ErrorController {

    @RequestMapping("/error")
    public String error(HttpServletRequest request, HttpServletResponse response, Model model) {
        Object code = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        int status = code instanceof Integer c ? c : 500;
        response.setStatus(status);
        model.addAttribute("code", status);
        return "error";
    }
}
  • Zeilen 14–16: der Controller der Fehlerseite, wie in Beispiel 24: Er implementiert die Schnittstelle [ErrorController] von [Spring Boot] und ersetzt damit die Standard-Fehlerseite;
  • Zeilen 18–21: Der Statuscode der Fehlerantwort (403, 404 usw.) ist ein Attribut der Anfrage; er wird in die Antwort und in das View-Template kopiert.

Die View [templates/error.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <div class="alert alert-danger">
    <h1 class="h4" th:text="|Error ${code}|">Error 403</h1>
    <p class="mb-0" th:text="${code == 403} ? 'Access denied: this page is reserved for administrators.' : 'An error occurred.'">message</p>
  </div>
  <p><a href="/profile">Back to the profile</a></p>
</main>
</body>
</html>
  • Zeile 7: eine spezifische Meldung für den Fehler 403 und eine allgemeine Meldung für die anderen.

Schließlich enthält die Profilseite einen weiteren Link zu [/admin]. Der Benutzer [marie] (Rolle USER) versucht, von ihrem Profil aus die Verwaltungsseite zu öffnen:

Image

Image

Derselbe Versuch von [admin]:

Image

Mit [curl]sehen wir einen Fehler 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
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">
    <main>
  <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>
</main>
  </div>
</body>
</html>

Die Fallstudie hat drei Rollen (ADMIN, DOCTOR, USER) und verwendet genau diese Mechanismen: Die Regel [anyRequest().authenticated()] schützt alle Seiten außer der Anmelde- und der Kontoerstellungsseite; [@PreAuthorize("hasRole('ADMIN')")] beschränkt den Zugriff auf die Verwaltung von Ärzten und Clients auf den Administrator; [@PreAuthorize("hasRole('USER')")] beschränkt den Zugriff auf den Patientenbereich auf Patienten. Dort wird die Seite 403 angezeigt.

8.3. Beispiel 27: CAPTCHA und Versuchsbegrenzung

Eine Anmeldeseite zieht Bots an: Programme, die Tausende verschiedener Kombinationen aus Benutzername und Passwort ausprobieren. Zwei einander ergänzende Schutzmaßnahmen:

  • ein CAPTCHA: ein Bild mit verzerrten Zeichen, das ein Mensch leicht lesen kann, ein einfacher Bot aber nicht entziffern kann;
  • eine Versuchsbegrenzung: Nach einigen fehlgeschlagenen Versuchen wird die IP-Adresse eine Weile gesperrt.

Beispiel 27 fügt Beispiel 25 diese beiden Schutzmaßnahmen hinzu. Die Datei [auth/CaptchaService.java]:

package example27.auth;

import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

import org.springframework.stereotype.Service;

// Singleton: die ausstehenden Captchas werden vom Server im Speicher gehalten
@Service
public class CaptchaService {

    // ein Captcha: seine Kennung und sein Bild (SVG)
    public record Captcha(String id, String svg) {
    }

    // die erwartete Antwort und ihr Ablaufdatum
    private record Expected(String text, Instant expires) {
    }

    private static final Duration LIFETIME = Duration.ofMinutes(10);

    // Kennung -> erwartete Antwort.
    // ConcurrentHashMap: ein Dictionary, das von mehreren gleichzeitigen Anfragen verwendet werden kann
    private final Map<String, Expected> pending = new ConcurrentHashMap<>();

    public Captcha generate() {
        String text = CaptchaDrawing.randomText(5);
        String id = UUID.randomUUID().toString(); // eine zufällige, nicht erratbare Kennung
        pending.put(id, new Expected(text, Instant.now().plus(LIFETIME)));
        return new Captcha(id, CaptchaDrawing.svg(text));
    }

    // das Captcha wird in jedem Fall VERBRAUCHT: ein Bild wird nur einmal verwendet
    public boolean check(String id, String input) {
        Expected expected = id == null ? null : pending.remove(id);
        return expected != null && input != null
                && expected.expires().isAfter(Instant.now())
                && expected.text().equalsIgnoreCase(input.trim());
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeilen 11–13: Ein Service ist ein Singleton-Bean (siehe Beispiel 06): eine einzige Instanz, die von allen Anfragen geteilt wird. Ausstehende CAPTCHAs werden daher vom Server im Speicher gehalten;
  • Zeilen 16–21: zwei Records: das an die Seite gesendete CAPTCHA (ID und Bild) und die erwartete, vom Server gespeicherte Antwort;
  • Zeile 27: Die erwarteten Antworten werden 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 wird von nebenläufigen Anfragen genutzt, die von verschiedenen Threads ausgeführt werden: [ConcurrentHashMap] ist ein Dictionary, das für diesen Zweck konzipiert ist;
  • Zeilen 29–34: eine zufällig erzeugte Zeichenkette aus fünf Zeichen, zehn Minuten lang gespeichert und als Bild gerendert. [UUID.randomUUID()] erzeugt eine zufällige 128-Bit-Kennung, die sich unmöglich erraten lässt;
  • Zeilen 37–42: Die Prüfung verbraucht das CAPTCHA ([remove] entfernt es aus dem Dictionary und gibt den entfernten Wert zurück): Ein Bild wird nur einmal verwendet; ein Bot kann eine bereits gefundene Lösung nicht wiederverwenden. Ein abgelaufenes CAPTCHA wird abgelehnt; Groß- und Kleinschreibung spielt keine Rolle ([equalsIgnoreCase]).

Das Bild wird von der Klasse [auth/CaptchaDrawing.java] behandelt, die aus der Fallstudie übernommen wurde. Es ist keine Bibliothek erforderlich: Das Bild liegt im Format [SVG] ([Scalable Vector Graphics]) vor, einem Vektor-Bildformat aus Text (XML), das der Browser anzeigen kann. Der Anfang der Datei:

// das Zeichnen eines Captchas: ein SVG-Bild (XML-Text), von Hand gebaut
final class CaptchaDrawing {

    private static final int WIDTH = 150;
    private static final int HEIGHT = 50;

    // SecureRandom: ein "kryptografischer" Zufallszahlengenerator,
    // unvorhersehbar (anders als Random, dessen Folge erraten werden könnte)
    private static final SecureRandom RANDOM = new SecureRandom();

    // Die "Schrift": jedes Zeichen ist eine Liste von Strichen, jeder Strich eine
    // Folge von Punkten (x, y) in einem 4 x 6-Raster (y zeigt nach unten).
    // Zeichen, die zu leicht miteinander verwechselt werden: ausgeschlossen (0 O, 1 I L).
    private static final Map<Character, double[][]> FONT = new LinkedHashMap<>();

    static {
  • Zeile 2: eine Klasse [final] (von der nicht geerbt werden kann), ohne das Schlüsselwort [public]: Sie ist nur für Klassen ihres Pakets sichtbar, [example27.auth];
  • Zeile 9: Die Zufallszahl wird von [SecureRandom] erzeugt, einem kryptografischen Generator: Die Folge seiner Ausgaben ist unvorhersehbar, selbst für jemanden, der die vorherigen Ausgaben kennt. Bei [Random] ist das nicht der Fall: Seine Folge lässt sich aus nur wenigen Ziehungen rekonstruieren; ein Bot könnte dann die folgenden CAPTCHAs vorhersagen;
  • Zeilen 11–14: Jedes Zeichen wird durch eine Liste von Strichen in einem kleinen Raster beschrieben. Leicht verwechselbare Zeichen (0 und O, 1, I und L) sind ausgeschlossen. Der Rest der Datei (hier nicht wiedergegeben) füllt dieses Dictionary in einem [static { ... }]-Block, der einmal beim Laden der Klasse ausgeführt wird.

Das Zeichnen des Bildes:

    static String svg(String text) {
        StringBuilder svg = new StringBuilder();
        svg.append("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"%d\" height=\"%d\" viewBox=\"0 0 %d %d\">"
                .formatted(WIDTH, HEIGHT, WIDTH, HEIGHT));
        svg.append("<rect width=\"100%\" height=\"100%\" fill=\"#f5f7fa\"/>");

        // die Zeichen: jedes vergrößert, geneigt, verschoben, und jeder Punkt
        // zufällig leicht bewegt
        double step = (WIDTH - 20) / (double) text.length();
        for (int i = 0; i < text.length(); i++) {
            double scale = random(4.6, 5.6); // Größe einer Rastereinheit, in Pixeln
            double angle = random(-0.35, 0.35); // Drehung, im Bogenmaß (etwa ±20°)
            double cx = 10 + step * (i + 0.5) + random(-3, 3); // Mittelpunkt des Zeichens
            double cy = HEIGHT / 2.0 + random(-4, 4);
            StringBuilder d = new StringBuilder();
            for (double[] stroke : FONT.get(text.charAt(i))) {
                for (int k = 0; k < stroke.length; k += 2) {
                    // Rasterpunkt, auf (2, 3) zentriert, verzerrt, gedreht, platziert
                    double x = (stroke[k] - 2 + random(-0.2, 0.2)) * scale;
                    double y = (stroke[k + 1] - 3 + random(-0.2, 0.2)) * scale;
                    double px = cx + x * Math.cos(angle) - y * Math.sin(angle);
                    double py = cy + x * Math.sin(angle) + y * Math.cos(angle);
                    d.append(k == 0 ? 'M' : 'L').append(number(px)).append(' ').append(number(py)).append(' ');
                }
            }
            svg.append("<path d=\"%s\" fill=\"none\" stroke=\"%s\" stroke-width=\"%s\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>"
                    .formatted(d.toString().trim(), color(), number(random(2.2, 3))));
        }

        // 3 Störstriche: Kurven, die das Bild durchqueren
        for (int n = 0; n < 3; n++) {
            svg.append("<path d=\"M%s %s C%s %s %s %s %s %s\" fill=\"none\" stroke=\"%s\" stroke-width=\"1.3\"/>"
                    .formatted(number(random(0, 20)), number(random(5, 45)),
                            number(random(30, 60)), number(random(0, 50)), number(random(90, 120)), number(random(0, 50)),
                            number(random(130, 150)), number(random(5, 45)), color()));
        }
        svg.append("</svg>");
        return svg.toString();
    }

    // eine Zahl mit Dezimalpunkt, unabhängig von der Sprache des Servers
    // (auf Französisch würde "%.1f" "12,5" schreiben - für SVG unlesbar)
    private static String number(double value) {
        return String.format(Locale.ROOT, "%.1f", value);
    }
  • Zeilen 3–5: Das SVG-Bild ist ein [<svg>]-Element von 150 x 50 Pixeln auf hellem Hintergrund (ein [<rect>]-Rechteck). ["...".formatted(...)] ersetzt [%d] und [%s] im Text durch die angegebenen Werte, ebenso wie [String.format];
  • Zeilen 9–28: Jedes Zeichen wird zu einem Pfad [<path>]: einer Folge von durch Segmente verbundenen Punkten ([M]: zum Punkt gehen; [L]: ein Segment zum Punkt zeichnen). Jedes Zeichen wird vergrößert, geneigt und zufällig verschoben, und jeder seiner Punkte wird leicht bewegt: Zwei Bilder desselben Textes sind nie identisch;
  • Zeilen 31–36: drei Störkurven ([C]: eine Bézierkurve) durchqueren das Bild, um ein Zeichenerkennungsprogramm zu verwirren;
  • Zeilen 43–45: Zahlen werden unabhängig von der Sprache des Servers mit einem Dezimalpunkt geschrieben ([Locale.ROOT]): Im Französischen würde [%.1f] ein Komma schreiben, das SVG nicht erkennt.

Die Datei [auth/LimiterService.java]:

package example27.auth;

import java.time.Duration;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Service;

// Singleton: zählt die Login-Fehlschläge jeder IP-Adresse
@Service
public class LimiterService {

    private static final int MAX_FAILURES = 3;
    private static final Duration BLOCK_DURATION = Duration.ofMinutes(1);

    private static class Counter {
        int failures;
        Instant blockedUntil = Instant.MIN;
    }

    private final Map<String, Counter> counters = new HashMap<>();

    // synchronized: mehrere gleichzeitige Anfragen, jeweils nur ein Zugriff

    // die Anzahl der verbleibenden Sperrsekunden (0: nicht gesperrt)
    public synchronized long blockedSeconds(String ip) {
        Counter c = counters.get(ip);
        if (c == null) {
            return 0;
        }
        Duration remaining = Duration.between(Instant.now(), c.blockedUntil);
        return remaining.isNegative() || remaining.isZero() ? 0 : (remaining.toMillis() + 999) / 1000;
    }

    public synchronized void failure(String ip) {
        Counter c = counters.computeIfAbsent(ip, key -> new Counter());
        c.failures++;
        if (c.failures >= MAX_FAILURES) {
            c.blockedUntil = Instant.now().plus(BLOCK_DURATION);
            c.failures = 0; // nach der Sperre beginnen wir wieder bei null
        }
    }

    public synchronized void success(String ip) {
        counters.remove(ip);
    }
}
  • Zeilen 14–15: Drei Fehlversuche sperren die IP-Adresse für eine Minute;
  • Zeilen 17–20: der Zähler einer Adresse: Anzahl der Fehlversuche und Enddatum der Sperre ([Instant.MIN], anfangs ein sehr weit zurückliegender Zeitpunkt);
  • Zeile 22: Das Zähler-Dictionary wird von allen Anfragen geteilt. Es ist eine einfache [HashMap], die keinen nebenläufigen Zugriff unterstützt: Jede Methode ist daher [synchronized]. Das Schlüsselwort stellt sicher, dass jeweils nur ein Thread eine der [synchronized]-Methoden des Objekts ausführt: Zwei gleichzeitige Fehlversuche können nicht auftreten (siehe [AtomicInteger], Kapitel 6);
  • Zeilen 27–34: die verbleibende Sperrzeit, auf die nächste Sekunde aufgerundet;
  • Zeilen 36–43: Ein Fehlversuch wird gezählt; beim dritten Fehlversuch wird die Adresse gesperrt. [computeIfAbsent] gibt den Zähler der Adresse zurück, nachdem es ihn erstellt hat, falls er nicht existierte;
  • Zeilen 45–47: Ein Erfolg setzt den Zähler zurück.

Die Datei [controllers/AuthController.java]:

package example27.controllers;

import java.util.Optional;

import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import example27.auth.AuthService;
import example27.auth.CaptchaService;
import example27.auth.LimiterService;
import example27.auth.UsersService.User;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@Controller
public class AuthController {

    private final AuthService auth;
    private final CaptchaService captchas;
    private final LimiterService limiter;

    public AuthController(AuthService auth, CaptchaService captchas, LimiterService limiter) {
        this.auth = auth;
        this.captchas = captchas;
        this.limiter = limiter;
    }

    @GetMapping("/")
    public String home() {
        return "redirect:/profile";
    }

    @GetMapping("/login")
    public String form(Model model) {
        return loginPage(model, null, null);
    }

    @PostMapping("/login")
    public String login(@RequestParam(required = false) String login,
            @RequestParam(required = false) String password, @RequestParam(required = false) String captchaId,
            @RequestParam(required = false) String captcha, HttpServletRequest request,
            HttpServletResponse response, Model model) {
        // die IP-Adresse des Clients
        String ip = request.getRemoteAddr();

        // 1. eine gesperrte Adresse wird nicht einmal angehört
        long seconds = limiter.blockedSeconds(ip);
        if (seconds > 0) {
            return loginPage(model, 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(model, login, "The image code is incorrect.");
        }
        Optional<User> user = auth.validate(login, password);
        if (user.isEmpty()) {
            limiter.failure(ip);
            return loginPage(model, login, "Incorrect login or password.");
        }
        limiter.success(ip);
        response.addHeader(HttpHeaders.SET_COOKIE, auth.cookie(auth.createToken(user.get())).toString());
        return "redirect:/profile";
    }

    // jede Anzeige des Formulars erzeugt ein NEUES Captcha
    private String loginPage(Model model, String login, String error) {
        model.addAttribute("login", login);
        model.addAttribute("error", error);
        model.addAttribute("captcha", captchas.generate());
        return "auth/login";
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeile 48: die IP-Adresse des Clients, von der Netzwerkverbindung bereitgestellt;
  • Zeilen 51–54: Eine gesperrte Adresse wird nicht einmal angehört;
  • Zeilen 56–59: Zuerst wird das CAPTCHA geprüft, dann – nur wenn das CAPTCHA korrekt ist – das Passwort (eine rechenintensive [bcrypt]-Operation). Ein falsches CAPTCHA zählt als Fehlversuch;
  • Zeilen 71–76: Bei jeder Anzeige des Formulars wird ein neues CAPTCHA erzeugt und in das View-Template eingefügt. Das gilt auch für die erste Anzeige (Zeilen 37–40).

Die Datei [templates/auth/login.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <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" th:value="${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" th:utext="${captcha.svg}">image</div>
      <!--/* die Captcha-Kennung reist in einem versteckten Feld; die Antwort bleibt auf dem Server */-->
      <input type="hidden" name="captchaId" th:value="${captcha.id}">
      <input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  <div class="alert alert-danger mt-3" th:if="${error != null}" th:text="${error}">error</div>
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
</main>
</body>
</html>
  • Zeile 18: Das SVG-Bild ist Text (aus XML): Es wird unverändert in die Seite eingefügt. [th:utext] ([unescaped text]) fügt den Text ohne Maskierung ein: Die Zeichen [<] und [>] bleiben Tags (mit [th:text] würden sie zu [&lt;] und [&gt;], und die Seite würde den Code des Bildes anzeigen). [th:utext] ist hier zulässig: Es handelt sich um vom Server erzeugtes HTML, nicht um Benutzereingaben;
  • Zeile 20: Die ID des CAPTCHAs wird in einem versteckten Feld übergeben; die Antwort bleibt jedoch auf dem Server;
  • Zeile 21: [autocomplete="off"]: Der Browser schlägt keine früheren Eingaben vor, die für ein CAPTCHA irrelevant sind.

Die Datei [config/SecurityConfig.java] ist genau dieselbe wie in Beispiel 25 (und nicht die aus Beispiel 26: Hier gibt es weder [@EnableMethodSecurity] noch einen Access-Denied-Handler, da keine Seite einer bestimmten Rolle vorbehalten ist). Insbesondere bleibt die Zugriffsregel [/login] unverändert: Die Anmeldeseite bleibt öffentlich, und das CAPTCHA wird vom Controller geprüft, nicht von [Spring Security].

Die Anmeldeseite unter der URL http://localhost:5000/login:

Image

Ein falsch eingegebenes CAPTCHA:

Image

Es wurde ein neues CAPTCHA erzeugt. Das erneute Absenden eines bereits verwendeten CAPTCHAs – selbst wenn es richtig eingegeben wurde – führt zur selben Meldung: Die Antwort wurde bei der ersten Prüfung aus dem Dictionary entfernt. Nach drei fehlgeschlagenen Versuchen wird selbst das richtige Passwort zusammen mit dem richtigen CAPTCHA eine Minute lang abgelehnt:

Image

Die Fallstudie wendet diese beiden Sicherheitsmaßnahmen auf ihre Anmeldeseite und die Kontoerstellung an, mit anpassbaren Schwellenwerten in der Datei [application.properties] (Eigenschaften [rdvmedecins.protection.*]).