Spring Security – zabezpieczenie aplikacji, uwierzytelnianie, autoryzacja, JWT

Bezpieczeństwo aplikacji to jeden z najważniejszych aspektów tworzenia nowoczesnych systemów informatycznych. W ekosystemie Spring za uwierzytelnianie użytkowników, zarządzanie uprawnieniami oraz ochronę przed popularnymi atakami odpowiada Spring Security.

Czym jest Spring Security?

Spring Security to moduł ekosystemu Spring Framework, który umożliwia zabezpieczanie aplikacji Java przed nieautoryzowanym dostępem. Dostarcza gotowe mechanizmy uwierzytelniania użytkowników, zarządzania uprawnieniami oraz ochrony przed popularnymi atakami.

Najważniejsze mechanizmy Spring Security

Spring Security udostępnia wiele mechanizmów związanych z bezpieczeństwem aplikacji. Do najważniejszych należą:

  • Authentication – obsługa uwierzytelniania użytkowników, np. poprzez login i hasło, HTTP Basic lub tokeny.
  • Authorization – kontrolowanie dostępu do endpointów i metod aplikacji na podstawie ról oraz uprawnień.
  • Password Encoding – bezpieczne przechowywanie haseł z wykorzystaniem algorytmów takich jak BCrypt.
  • Session Management – zarządzanie sesjami użytkowników w aplikacjach korzystających z uwierzytelniania sesyjnego.
  • OAuth2 i JWT – integracja z rozwiązaniami opartymi na tokenach, wykorzystywanymi m.in. do zabezpieczania REST API.
  • CSRF Protection – ochrona przed atakami Cross-Site Request Forgery.
  • Security Headers – automatyczne dodawanie nagłówków HTTP zwiększających bezpieczeństwo aplikacji.

Architektura Spring Security

Spring Security opiera się przede wszystkim na mechanizmie filtrów HTTP, które przechwytują żądania przychodzące do aplikacji, zanim trafią one do kontrolerów.

Dzięki temu framework może sprawdzić tożsamość użytkownika, zweryfikować jego uprawnienia i zdecydować, czy żądanie powinno zostać obsłużone.

SecurityFilterChain – łańcuch filtrów bezpieczeństwa

Podstawowym elementem architektury Spring Security jest SecurityFilterChain, czyli łańcuch filtrów odpowiedzialnych za zabezpieczanie żądań HTTP.

Każdy filtr realizuje określone zadanie. Przykładowo:

  • CsrfFilter – odpowiada za ochronę przed atakami CSRF.
  • UsernamePasswordAuthenticationFilter – obsługuje uwierzytelnianie za pomocą formularza logowania.
  • BasicAuthenticationFilter – obsługuje uwierzytelnianie HTTP Basic.
  • BearerTokenAuthenticationFilter – przetwarza tokeny Bearer, np. JWT.
  • AuthorizationFilter – sprawdza, czy użytkownik ma uprawnienia do wykonania żądania.

To, które filtry zostaną uruchomione, zależy od konfiguracji aplikacji.

Jak działa łańcuch filtrów bezpieczeństwa?

Aby zrozumieć działanie Spring Security, warto najpierw przypomnieć sobie, czym są filtry w technologii Servlet.

Filtr to komponent, który przechwytuje żądania HTTP, zanim trafią one do właściwego serwletu, np. DispatcherServlet w Spring MVC. Pozwala to wykonywać dodatkowe operacje niezależnie od logiki biznesowej aplikacji.

Każdy filtr implementuje interfejs Filter i udostępnia metodę doFilter(), która otrzymuje trzy argumenty:

  • ServletRequest – żądanie HTTP.
  • ServletResponse – odpowiedź HTTP.
  • FilterChain – obiekt umożliwiający przekazanie żądania do kolejnego filtra lub docelowego serwletu.

Przykładowy filtr może wyglądać następująco:

public class LoggingFilter implements Filter {

    @Override
    public void doFilter(
            ServletRequest request,
            ServletResponse response,
            FilterChain chain)
            throws IOException, ServletException {

        System.out.println("Przed obsługą żądania");

        chain.doFilter(request, response);

        System.out.println("Po obsłudze żądania");
    }
}

Wywołanie chain.doFilter() powoduje przekazanie żądania do kolejnego elementu łańcucha. Jeśli filtr nie wywoła tej metody, może zatrzymać dalsze przetwarzanie żądania.

Spring Security wykorzystuje dokładnie ten sam mechanizm, tworząc własny łańcuch filtrów odpowiedzialnych za bezpieczeństwo aplikacji, nazywany SecurityFilterChain.

AuthenticationManager i AuthenticationProvider

Za proces uwierzytelniania odpowiada interfejs AuthenticationManager.

Jego zadaniem jest przyjęcie obiektu Authentication zawierającego dane uwierzytelniające użytkownika i sprawdzenie, czy można potwierdzić jego tożsamość.

Najczęściej wykorzystywaną implementacją tego interfejsu jest ProviderManager, który deleguje uwierzytelnianie do jednego lub kilku obiektów implementujących interfejs AuthenticationProvider.

AuthenticationProvider odpowiada za konkretny mechanizm uwierzytelniania. Przykładowo DaoAuthenticationProvider wykorzystuje UserDetailsService do pobrania informacji o użytkowniku oraz PasswordEncoder do weryfikacji hasła.

Schemat współpracy tych komponentów wygląda następująco:

AuthenticationManager
        |
        v
   ProviderManager
        |
        +-- DaoAuthenticationProvider
        |       |
        |       +-- UserDetailsService
        |       +-- PasswordEncoder
        |
        +-- Inny AuthenticationProvider

Dzięki takiej architekturze aplikacja może obsługiwać różne sposoby uwierzytelniania bez konieczności modyfikowania logiki kontrolerów.

SecurityContextHolder i SecurityContext

Po pomyślnym uwierzytelnieniu Spring Security udostępnia informacje o zalogowanym użytkowniku za pośrednictwem SecurityContextHolder.

W tym mechanizmie występują trzy podstawowe elementy:

  • SecurityContextHolder – udostępnia aktualny kontekst bezpieczeństwa. Domyślnie wykorzystuje ThreadLocal, dzięki czemu kontekst jest powiązany z bieżącym wątkiem.
  • SecurityContext – przechowuje obiekt Authentication.
  • Authentication – reprezentuje dane uwierzytelnienia, w tym tożsamość użytkownika (principal), jego uprawnienia (authorities) i status uwierzytelnienia.

Informacje o aktualnym użytkowniku można pobrać w następujący sposób:

Authentication authentication =
    SecurityContextHolder.getContext().getAuthentication();

String username = authentication.getName();

Collection<? extends GrantedAuthority> authorities =
    authentication.getAuthorities();

W powyższym przykładzie odczytuję nazwę użytkownika oraz przypisane mu uprawnienia. Kod zakłada, że w kontekście znajduje się obiekt Authentication.

Ważne jest również to, że SecurityContextHolder nie stanowi trwałego magazynu danych. W aplikacjach sesyjnych kontekst może być przechowywany między żądaniami, np. w sesji HTTP. Natomiast w aplikacjach bezstanowych korzystających z JWT uwierzytelnienie jest zazwyczaj odtwarzane na podstawie tokenu przy każdym żądaniu.

Konfiguracja Spring Security w Spring Boot

Spring Security można zintegrować z aplikacją Spring Boot za pomocą jednej zależności. Framework automatycznie dostarcza podstawowe zabezpieczenia, które następnie można dostosować do potrzeb aplikacji.

Dodanie zależności Spring Security

W przypadku projektu korzystającego z Mavena wystarczy dodać do pliku pom.xml następującą zależność:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Boot automatycznie skonfiguruje podstawowe mechanizmy bezpieczeństwa.

Domyślne zabezpieczenia Spring Security

Po dodaniu zależności Spring Security wszystkie endpointy aplikacji są domyślnie zabezpieczone i wymagają uwierzytelnienia.

Spring Boot automatycznie tworzy również tymczasowego użytkownika:

  • Login: user
  • Hasło: generowane losowo przy uruchomieniu aplikacji i wyświetlane w logach.

W zależności od rodzaju żądania Spring Security wykorzystuje domyślnie formularz logowania lub HTTP Basic Authentication.

Domyślna konfiguracja służy przede wszystkim do celów deweloperskich. W rzeczywistej aplikacji powinno się samodzielnie zdefiniować zasady dostępu oraz sposób uwierzytelniania użytkowników.

Konfiguracja SecurityFilterChain

Współczesne wersje Spring Security umożliwiają konfigurację zabezpieczeń poprzez zdefiniowanie beana SecurityFilterChain.

Przykładowa konfiguracja może wyglądać następująco:

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) {

        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults());

        return http.build();
    }
}

W powyższym przykładzie:

  • @Configuration – oznacza klasę konfiguracyjną Spring.
  • @Bean – rejestruje SecurityFilterChain w kontekście Spring.
  • HttpSecurity – obiekt umożliwiający konfigurację zabezpieczeń HTTP.
  • authorizeHttpRequests() – definiuje zasady dostępu do endpointów.
  • requestMatchers("/api/public/**").permitAll() – pozwala na dostęp do wskazanych endpointów bez uwierzytelnienia.
  • anyRequest().authenticated() – wymaga uwierzytelnienia dla wszystkich pozostałych żądań.
  • httpBasic() – włącza uwierzytelnianie HTTP Basic.
  • http.build() – buduje skonfigurowany łańcuch filtrów bezpieczeństwa.

Warto zaznaczyć, że reguły dostępu są sprawdzane w kolejności ich deklarowania.

Przykład zabezpieczenia endpointów REST API

Załóżmy, że aplikacja udostępnia dwa endpointy:

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/public/hello")
    public String hello() {
        return "Hello!";
    }

    @GetMapping("/profile")
    public String profile() {
        return "Private user profile";
    }
}

Przy wykorzystaniu wcześniejszej konfiguracji Spring Security zachowanie aplikacji będzie następujące:

EndpointBez logowaniaPo uwierzytelnieniu
GET /api/public/hello200 OK200 OK
GET /api/profile401 Unauthorized200 OK

Teraz, aby dostać się do endpointu /api/profile należy wysłać żądanie HTTP GET do endpointu /api/profile, wykorzystując mechanizm HTTP Basic Authentication. Czyli umieścić hasło w nagłówku żądania w sekcji Authorization, najlepiej w formacie Base64 (ale plain text też tu zadziała).

Przykładowe prawidlowe żądanie HTTP:

GET /api/profile HTTP/1.1
Host: localhost:8080
Authorization: Basic dXNlcjpwYXNzd29yZDEyMw==

Jeśli haslo jest prawidłowe, użytkownik otrzyma dostęp do powyższego endpointu.

Co dzieje się pod spodem?

Spring Security:

  1. Przechwytuje żądanie przez BasicAuthenticationFilter.
  2. Odczytuje nagłówek Authorization.
  3. Dekoduje dane Base64, uzyskując login i hasło.
  4. Weryfikuje dane uwierzytelniające.
  5. Jeśli dane są poprawne, umożliwia dostęp do endpointu.

Ważne: Base64 to kodowanie, a nie szyfrowanie. Przesłane w ten sposób hasło, może zostać odkodowane przez każdego, kto przechwyci żądanie.

Czym jest HttpSecurity?

HttpSecurity to podstawowy obiekt wykorzystywany do konfigurowania zabezpieczeń HTTP w Spring Security.

Pozwala między innymi na:

  • Określanie dostępu do poszczególnych endpointów.
  • Konfigurację mechanizmów logowania.
  • Zarządzanie sesjami użytkowników.
  • Konfigurację ochrony CSRF i CORS.
  • Dodawanie własnych filtrów bezpieczeństwa.

Uwierzytelnianie użytkowników

Uwierzytelnianie (Authentication) to proces weryfikacji tożsamości użytkownika. Spring Security obsługuje różne mechanizmy uwierzytelniania, m.in. login i hasło, tokeny JWT oraz zewnętrznych dostawców tożsamości.

Spring Security udostępnia dwa podstawowe mechanizmy uwierzytelniania oparte na loginie i haśle.

HTTP Basic Authentication

W tym mechanizmie klient przesyła login i hasło w nagłówku Authorization każdego żądania wymagającego uwierzytelnienia (przykład z poprzedniego rozdziału).

W konfiguracji Spring Security włączyłem go za pomocą:

.httpBasic(Customizer.withDefaults());

Dane są zakodowane przy użyciu Base64, który nie zapewnia szyfrowania. Dlatego HTTP Basic powinien być wykorzystywany wyłącznie przez HTTPS.

Mechanizm ten obsługiwany jest przez filtr BasicAuthenticationFilter.

Form Login

W tym przypadku użytkownik wprowadza login i hasło w formularzu HTML. Spring Security domyślnie udostępnia stronę logowania pod adresem /login, jeśli włączymy ten mechanizm w konfiguracji:

http.formLogin(Customizer.withDefaults());

Po pomyślnym zalogowaniu aplikacja może przechowywać informacje o uwierzytelnionym użytkowniku w sesji HTTP. Dzięki temu użytkownik nie musi ponownie przesyłać loginu i hasła przy każdym żądaniu.

UserDetails i UserDetailsService

W przypadku uwierzytelniania za pomocą loginu i hasła Spring Security potrzebuje informacji o użytkowniku, takich jak login, hash hasła oraz przypisane uprawnienia.

Służą do tego dwa, już zaimplementowane w Spring Security, interfejsy:

  • UserDetails – reprezentuje użytkownika w Spring Security. Udostępnia login, hash hasła, uprawnienia oraz informacje o stanie konta.
  • UserDetailsService – odpowiada za pobranie danych użytkownika na podstawie jego loginu.

Interfejs UserDetailsService definiuje tylko jedną metodę:

UserDetails loadUserByUsername(String username)
    throws UsernameNotFoundException;

Warto podkreślić, że UserDetailsService nie weryfikuje hasła użytkownika. Jego zadaniem jest wyłącznie pobranie danych. Weryfikacją hasła zajmuje się AuthenticationProvider, najczęściej DaoAuthenticationProvider.

Spring Security udostępnia również gotową implementację UserDetails w postaci klasy User.

Pobieranie użytkowników z bazy danych

W rzeczywistych aplikacjach informacje o użytkownikach najczęściej przechowywane są w bazie danych.

Załóżmy, że w swoim projekcie posiadam encję AppUser, zawierającą następujące pola:

  • username – login użytkownika.
  • passwordHash – hash hasła.
  • role – rola użytkownika, np. USER lub ADMIN.

Następnie tworzę własną implementację UserDetailsService. Do pobierania użytkowników wykorzystam repozytorium Spring Data JPA o nazwie AppUserRepository.

@Service
public class DatabaseUserDetailsService
        implements UserDetailsService {

    private final AppUserRepository repository;

    public DatabaseUserDetailsService(
            AppUserRepository repository) {
        this.repository = repository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) {

        AppUser user = repository.findByUsername(username)
            .orElseThrow(() ->
                new UsernameNotFoundException("User not found")
            );

        return User.withUsername(user.getUsername())
            .password(user.getPasswordHash())
            .roles(user.getRole())
            .build();
    }
}

W powyższym przykładzie:

  1. Spring Security wywołuje metodę loadUserByUsername(), przekazując login użytkownika.
  2. Metoda pobiera użytkownika z bazy danych za pomocą AppUserRepository.
  3. Jeśli użytkownik nie istnieje, zgłaszany jest wyjątek UsernameNotFoundException.
  4. Jeśli użytkownik istnieje, jego dane są przekształcane w obiekt UserDetails, który następnie wykorzystywany jest do uwierzytelniania.

Metoda roles() automatycznie dodaje prefiks ROLE_, dlatego przekazujemy do niej np. USER, a nie ROLE_USER.

Zarejestrowanie własnego UserDetailsService pozwala Spring Security wykorzystać użytkowników z naszej bazy danych zamiast domyślnego użytkownika generowanego przez Spring Boot.PasswordEncoder i BCrypt

Hasła użytkowników nigdy nie powinny być przechowywane w bazie danych w postaci zwykłego tekstu.

Spring Security udostępnia interfejs PasswordEncoder, który odpowiada za hashowanie haseł oraz ich późniejszą weryfikację.

Jedną z najczęściej wykorzystywanych implementacji jest BCryptPasswordEncoder, który korzysta z algorytmu BCrypt.

Przykład konfiguracji:

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

Interfejs PasswordEncoder udostępnia dwie podstawowe metody:

String hash = passwordEncoder.encode("password123");

boolean valid = passwordEncoder.matches(
    "password123",
    hash
);
  • matches() – sprawdza, czy podane hasło odpowiada zapisanemu hash’owi.
  • encode() – generuje hash hasła, który powinien zostać zapisany w bazie danych.

Jak przebiega proces uwierzytelniania?

Mając już omówione najważniejsze komponenty, prześledźmy cały proces uwierzytelniania użytkownika.

Schemat procesu uwierzytelniania w Spring Security przedstawiający współpracę AuthenticationManager, DaoAuthenticationProvider, UserDetailsService, PasswordEncoder i SecurityContext.
Proces uwierzytelniania w Spring Security – od przesłania loginu i hasła, przez weryfikację danych użytkownika, aż do uzyskania dostępu do chronionego zasobu.

Filtr odczytuje dane uwierzytelniające, AuthenticationManager przekazuje je do DaoAuthenticationProvider, który pobiera użytkownika i sprawdza hasło. Po pomyślnej weryfikacji Spring Security zapisuje informacje o uwierzytelnieniu w SecurityContext.

W typowej aplikacji Spring Boot nie musisz implementować ani ręcznie konfigurować DaoAuthenticationProvider. Wystarczy dostarczyć UserDetailsService i odpowiedni PasswordEncoder, a Spring Security może zbudować resztę infrastruktury.

Autoryzacja i zarządzanie uprawnieniami

Autoryzacja (Authorization) to proces sprawdzania, czy uwierzytelniony użytkownik posiada odpowiednie uprawnienia do wykonania określonej operacji lub uzyskania dostępu do zasobu.

Spring Security umożliwia kontrolowanie dostępu zarówno na poziomie endpointów HTTP, jak i poszczególnych metod aplikacji.

Role i uprawnienia – Role vs Authority

W Spring Security uprawnienia użytkownika reprezentowane są przez interfejs GrantedAuthority.

Interfejs ten definiuje jedną metodę:

String getAuthority();

Spring Security udostępnia jego gotową implementację SimpleGrantedAuthority, która przechowuje uprawnienie w postaci tekstowej.

Przykładowo użytkownik może posiadać następujące uprawnienia:

ROLE_USER
USER_READ
USER_WRITE

Warto rozróżnić dwa pojęcia:

  • Role (role) – reprezentują grupy użytkowników, np. USER lub ADMIN.
  • Authorities (uprawnienia) – reprezentują konkretne uprawnienia, np. USER_READ lub USER_DELETE.

Z technicznego punktu widzenia Spring Security traktuje role jako szczególny rodzaj uprawnień. Domyślnie rozpoznaje je na podstawie prefiksu ROLE_.

Przykładowo możemy utworzyć użytkownika posiadającego rolę administratora:

UserDetails user = User.withUsername("admin")
    .password(passwordHash)
    .roles("ADMIN")
    .build();

Metoda roles("ADMIN") automatycznie tworzy uprawnienie ROLE_ADMIN.

Równoważny zapis wygląda następująco:

UserDetails user = User.withUsername("admin")
    .password(passwordHash)
    .authorities("ROLE_ADMIN")
    .build();

Spring Security nie narzuca sztywnego podziału na role i uprawnienia. To od projektanta aplikacji zależy, w jaki sposób zostaną one zorganizowane.

hasRole() i hasAuthority()

Spring Security udostępnia metody pozwalające sprawdzić, czy użytkownik posiada określoną rolę lub uprawnienie.

Najczęściej wykorzystujemy:

MetodaDziałanie
hasRole("ADMIN")Wymaga uprawnienia ROLE_ADMIN
hasAnyRole("USER", "ADMIN")Wymaga przynajmniej jednej z podanych ról
hasAuthority("USER_READ")Wymaga dokładnie wskazanego uprawnienia
hasAnyAuthority("USER_READ", "USER_WRITE")Wymaga przynajmniej jednego z podanych uprawnień

Najważniejsza różnica polega na tym, że hasRole() automatycznie uwzględnia prefiks ROLE_, natomiast hasAuthority() sprawdza dokładną nazwę uprawnienia.

Przykładowo:

hasRole("ADMIN")

jest domyślnie odpowiednikiem:

hasAuthority("ROLE_ADMIN")

Prefiks ROLE_ można zmienić w konfiguracji Spring Security.

Autoryzacja na poziomie endpointów

Dostęp do poszczególnych endpointów możemy kontrolować za pomocą metody authorizeHttpRequests() w konfiguracji SecurityFilterChain.

Przykładowo:

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(
            HttpSecurity http) {

        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/users/**")
                    .hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults());

        return http.build();
    }
}

W powyższym przykładzie endpointy /api/public/** są dostępne dla wszystkich użytkowników. Dostęp do /api/admin/** wymaga roli ADMIN, natomiast /api/users/** może być obsługiwany przez użytkowników z rolą USER lub ADMIN.

Wszystkie pozostałe żądania wymagają uwierzytelnienia, ale nie konkretnej roli.

Reguły są sprawdzane w kolejności ich deklarowania. Spring Security wykorzystuje pierwszą pasującą regułę, dlatego bardziej szczegółowe warunki należy umieszczać przed ogólnymi.

Możemy również ograniczać dostęp na podstawie metody HTTP:

.requestMatchers(HttpMethod.GET, "/api/users/**")
    .hasAuthority("USER_READ")

.requestMatchers(HttpMethod.DELETE, "/api/users/**")
    .hasAuthority("USER_DELETE")

Dzięki temu użytkownik posiadający uprawnienie USER_READ może pobierać dane, ale nie może ich usuwać, jeśli nie posiada dodatkowego uprawnienia USER_DELETE.

Oczywiście takie uprawnienia muszą być wcześniej przypisane użytkownikowi, np. podczas tworzenia jego obiektu UserDetails.

Autoryzacja na poziomie metod – @PreAuthorize

Spring Security pozwala również kontrolować dostęp do konkretnych metod aplikacji, niezależnie od tego, z którego endpointu są wywoływane.

Aby aktywować ten mechanizm, należy dodać adnotację @EnableMethodSecurity:

@Configuration
@EnableMethodSecurity
public class SecurityConfig {
}

Następnie możemy wykorzystać adnotację @PreAuthorize:

@Service
public class UserService {

    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        // Usunięcie użytkownika
    }

    @PreAuthorize("hasAuthority('USER_READ')")
    public List<User> findAll() {
        // Pobranie użytkowników
    }
}

W powyższym przykładzie metoda deleteUser() może zostać wykonana wyłącznie przez użytkownika posiadającego rolę ADMIN, natomiast findAll() wymaga uprawnienia USER_READ.

@PreAuthorize sprawdza uprawnienia przed wykonaniem metody. Jeśli użytkownik nie spełnia określonego warunku, Spring Security odmawia dostępu.

Mechanizm ten wykorzystuje Spring AOP i proxy, dlatego obowiązują podobne ograniczenia jak w przypadku @Transactional. Przykładowo wywołanie metody zabezpieczonej @PreAuthorize z innej metody tego samego obiektu nie przechodzi przez proxy, przez co kontrola uprawnień może zostać pominięta.

Bardziej zaawansowane warunki autoryzacji

Adnotacja @PreAuthorize obsługuje również wyrażenia SpEL (Spring Expression Language), dzięki którym możemy definiować bardziej złożone reguły dostępu.

Przykładowo:

@PreAuthorize("#username == authentication.name or hasRole('ADMIN')")
public User getUser(String username) {
    return userRepository.findByUsername(username)
        .orElseThrow();
}

W tym przypadku metoda może zostać wykonana, jeżeli użytkownik próbuje pobrać własne dane lub posiada rolę administratora.

W wyrażeniu wykorzystujemy:

  • #username – argument metody.
  • authentication.name – nazwę aktualnie uwierzytelnionego użytkownika.
  • hasRole('ADMIN') – sprawdzenie roli administratora.

Dzięki temu możemy definiować uprawnienia nie tylko na podstawie ról, ale również konkretnych danych przekazywanych do metody.

Token JWT i zabezpieczanie REST API

W nowoczesnych aplikacjach REST API coraz częściej wykorzystuje się uwierzytelnianie oparte na tokenach zamiast tradycyjnych sesji HTTP.

Jednym z najpopularniejszych formatów tokenów jest JWT (JSON Web Token), który pozwala przekazywać informacje o tożsamości użytkownika oraz jego uprawnieniach w postaci podpisanego cyfrowo tokenu.

W nowoczesnych aplikacjach REST API coraz częściej wykorzystuje się uwierzytelnianie oparte na tokenach zamiast tradycyjnych sesji HTTP.

Jednym z najpopularniejszych formatów tokenów jest JWT (JSON Web Token), który pozwala przekazywać informacje o tożsamości użytkownika oraz jego uprawnieniach w postaci podpisanego cyfrowo tokenu.

Czym jest JWT?

JWT to standard opisany w RFC 7519, definiujący sposób bezpiecznego przekazywania informacji między systemami w formacie JSON.

Typowy podpisany token JWT (JWS) składa się z trzech części oddzielonych kropkami:

header.payload.signature

Każda z nich pełni określoną funkcję:

  1. Header – zawiera informacje o typie tokenu i algorytmie użytym do podpisania, np. RS256.
  2. Payload – zawiera dane użytkownika i dodatkowe informacje, tzw. claims.
  3. Signature – podpis kryptograficzny pozwalający zweryfikować integralność tokenu i jego pochodzenie od zaufanego wystawcy.

Na przykład:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwicm9sZSI6IkFETUlOIiwiaWF0IjoxNzk1MDY4MDAwLCJleHAiOjE3OTUwNzE2MDB9.yT-8iZnssOlOVxNhPLobXpdnVoVio00GW3epPZY38cg

Taki token nie jest zaszyfrowany. Możesz go zdekodować np. na stronie https://www.jwt.io/

Uwierzytelnianie sesyjne a bezstanowe

W tradycyjnym uwierzytelnianiu sesyjnym serwer przechowuje informacje o zalogowanym użytkowniku, np. w sesji HTTP. Klient otrzymuje identyfikator sesji w ciasteczku i przesyła go przy kolejnych żądaniach.

W przypadku uwierzytelniania bezstanowego z wykorzystaniem JWT serwer nie musi utrzymywać sesji użytkownika. Zamiast tego klient dołącza token do każdego żądania, a serwer weryfikuje jego poprawność.

CechaSesja HTTPJWT (bezstanowy)
Stan uwierzytelnieniaPrzechowywany po stronie serweraPrzenoszony w tokenie
Identyfikacja użytkownikaIdentyfikator sesjiToken JWT
WeryfikacjaOdczyt danych sesjiWeryfikacja tokenu
UnieważnienieZwykle proste, przez usunięcie sesjiWymaga dodatkowego mechanizmu lub oczekiwania na wygaśnięcie
SkalowanieMoże wymagać współdzielonego magazynu sesjiNie wymaga współdzielonej sesji

JWT jest szczególnie przydatny w architekturze mikroserwisowej, ponieważ różne usługi mogą niezależnie weryfikować token przy użyciu odpowiedniego klucza kryptograficznego.

Jak działa uwierzytelnianie z JWT?

Typowy proces wygląda następująco:

  1. Użytkownik uwierzytelnia się w systemie, np. podając login i hasło.
  2. Serwer odpowiedzialny za uwierzytelnianie wystawia podpisany token JWT.
  3. Klient otrzymuje token i przechowuje go w odpowiedni sposób.
  4. Przy kolejnych żądaniach klient przesyła token w nagłówku Authorization.
  5. Spring Security weryfikuje podpis tokenu, jego ważność oraz wymagane informacje, takie jak wystawca.
  6. Jeśli token jest poprawny, Spring Security tworzy obiekt Authentication, na podstawie którego przeprowadzana jest autoryzacja.

Przykładowe żądanie:

GET /api/profile HTTP/1.1
Host: localhost:8080
Authorization: Bearer eyJhbGciOiJSUzI1NiIs...

W odróżnieniu od HTTP Basic, w którym klient przesyła login i hasło, tutaj przekazywany jest token Bearer, uprawniający jego posiadacza do korzystania z określonych zasobów.

Z tego powodu JWT również musi być chroniony przed przechwyceniem, a komunikacja powinna odbywać się przez HTTPS.

OAuth2 Resource Server

Spring Security udostępnia gotowy mechanizm weryfikacji tokenów JWT w ramach OAuth2 Resource Server.

Resource Server to aplikacja udostępniająca chronione zasoby, np. REST API. Nie musi ona samodzielnie logować użytkowników ani wystawiać tokenów — może weryfikować tokeny wydawane przez zewnętrzny Authorization Server, np. Keycloak.

W Spring Boot 4 możemy skorzystać z zależności:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security-oauth2-resource-server</artifactId>
</dependency>

To nazwa startera zalecana w Spring Boot 4, zastępująca starszy spring-boot-starter-oauth2-resource-server.

Następnie w application.yml wskazujemy adres zaufanego wystawcy tokenów:

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://auth.example.com
          audiences:
            - my-api

Adres https://auth.example.com jest przykładowy — w rzeczywistej aplikacji należy podać adres działającego serwera autoryzacyjnego, udostępniającego odpowiednie metadane i klucze publiczne.

Alternatywnie można samemu dekodować tokeny JWT za pomocą biblioteki java-jwt.

Konfiguracja SecurityFilterChain dla JWT

Przykładowa konfiguracja zabezpieczeń REST API może wyglądać następująco:

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) {

        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/users/**")
                    .hasAuthority("SCOPE_user.read")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(Customizer.withDefaults())
            );

        return http.build();
    }
}

W powyższym przykładzie:

  • csrf().disable() – wyłącza ochronę CSRF. Jest to typowe rozwiązanie dla bezstanowego REST API, w którym token przesyłany jest wyłącznie w nagłówku Authorization, a przeglądarka nie dołącza automatycznie danych uwierzytelniających.
  • SessionCreationPolicy.STATELESS – określa, że Spring Security nie będzie tworzył ani wykorzystywał sesji HTTP do przechowywania kontekstu bezpieczeństwa.
  • hasAuthority("SCOPE_user.read") – wymaga uprawnienia user.read pochodzącego z tokenu JWT.
  • oauth2ResourceServer().jwt() – aktywuje mechanizm uwierzytelniania na podstawie tokenów JWT.

Jeśli aplikacja wykorzystuje ciasteczka do uwierzytelniania, wyłączenie CSRF niekoniecznie będzie bezpieczne. Mechanizm ten omówimy w kolejnym rozdziale.

Jak Spring Security weryfikuje JWT?

Za obsługę tokenów Bearer odpowiada BearerTokenAuthenticationFilter.

Po otrzymaniu żądania filtr odczytuje token z nagłówka Authorization, a następnie przekazuje go do mechanizmu uwierzytelniania.

W przypadku JWT wykorzystywany jest JwtAuthenticationProvider, który współpracuje z dwoma komponentami:

  • JwtDecoder – dekoduje token i weryfikuje jego podpis oraz wymagane claims.
  • JwtAuthenticationConverter – przekształca zweryfikowany token JWT w obiekt Authentication, zawierający informacje o użytkowniku i jego uprawnieniach.

Domyślnie Spring Security przekształca wartości scope lub scp z tokenu w uprawnienia z prefiksem SCOPE_.

Przykładowo token zawierający:

{
  "scope": "user.read user.write"
}

pozwala utworzyć następujące uprawnienia:

SCOPE_user.read
SCOPE_user.write

Dzięki temu możemy wykorzystywać poznane wcześniej mechanizmy autoryzacji, takie jak hasAuthority() i @PreAuthorize.

Warto zauważyć, że w tym przypadku nie potrzebujemy UserDetailsService ani PasswordEncoder do weryfikowania każdego żądania. Tożsamość użytkownika jest ustalana na podstawie prawidłowo zweryfikowanego tokenu JWT. Home+1

Access Token i Refresh Token

W aplikacjach wykorzystujących OAuth2 często spotykamy dwa rodzaje tokenów:

  • Access Token – token o stosunkowo krótkim czasie ważności, wykorzystywany do uzyskiwania dostępu do chronionych zasobów.
  • Refresh Token – token umożliwiający uzyskanie nowego Access Token bez konieczności ponownego uwierzytelniania użytkownika.

Ochrona przed popularnymi atakami – CSRF, CORS i Security Headers

Spring Security udostępnia mechanizmy chroniące aplikację przed popularnymi zagrożeniami związanymi z komunikacją HTTP.

CSRF – Cross-Site Request Forgery

CSRF to atak polegający na nakłonieniu przeglądarki zalogowanego użytkownika do wykonania niepożądanej operacji, np. przelewu bankowego. Wykorzystuje fakt, że przeglądarka może automatycznie dołączać ciasteczka sesyjne do żądań.

Spring Security domyślnie chroni przed CSRF, wymagając odpowiedniego tokenu dla żądań modyfikujących stan aplikacji.

W przypadku bezstanowego REST API, które korzysta wyłącznie z JWT przesyłanego w nagłówku Authorization, ochronę CSRF zazwyczaj można wyłączyć:

http.csrf(csrf -> csrf.disable());

Jeżeli jednak uwierzytelnianie wykorzystuje ciasteczka, ochrona CSRF nadal może być konieczna.

CORS – Cross-Origin Resource Sharing

CORS to mechanizm kontrolujący, czy przeglądarka może odczytywać odpowiedzi z serwera znajdującego się pod innym adresem (origin).

Przykładowo frontend działający na localhost:3000 komunikuje się z REST API na localhost:8080.

Spring Security umożliwia włączenie obsługi CORS:

http.cors(Customizer.withDefaults());

Do prawidłowego działania potrzebna jest również konfiguracja dozwolonych źródeł, metod i nagłówków, np. za pomocą beana CorsConfigurationSource lub konfiguracji Spring MVC.

CORS nie zastępuje uwierzytelniania ani autoryzacji – ograniczenia te egzekwują przeglądarki, a nie np. curl czy Postman.

Security Headers – nagłówki bezpieczeństwa

Spring Security automatycznie dodaje do odpowiedzi HTTP nagłówki zwiększające bezpieczeństwo aplikacji.

Do najważniejszych należą:

  • X-Content-Type-Options – zapobiega niepożądanemu wykrywaniu typu MIME.
  • X-Frame-Options – chroni przed osadzaniem strony w ramkach, ograniczając ryzyko clickjackingu.
  • Strict-Transport-Security – wymusza korzystanie z HTTPS przez przeglądarkę po otrzymaniu nagłówka HSTS.
  • Cache-Control – ogranicza przechowywanie odpowiedzi w pamięci podręcznej.

Spring Security obsługuje również Content-Security-Policy (CSP), jednak jej konfigurację musimy zdefiniować samodzielnie.

Obsługa błędów

Spring Security automatycznie obsługuje błędy związane z uwierzytelnianiem i autoryzacją. Umożliwia również testowanie zabezpieczeń bez konieczności wykonywania rzeczywistego procesu logowania.

HTTP 401 vs 403

W kontekście Spring Security najważniejsze są dwa kody odpowiedzi HTTP:

  • 401 Unauthorized – użytkownik nie został poprawnie uwierzytelniony, np. nie przesłał tokenu JWT lub podał nieprawidłowe hasło.
  • 403 Forbidden – użytkownik został uwierzytelniony, ale nie posiada odpowiednich uprawnień do wykonania operacji.

Spring Security wykorzystuje dwa interfejsy do obsługi takich sytuacji:

  • AuthenticationEntryPoint – odpowiada za rozpoczęcie procesu uwierzytelniania, np. zwrócenie HTTP 401 w REST API.
  • AccessDeniedHandler – obsługuje odmowę dostępu, zazwyczaj zwracając HTTP 403.

Działanie obu komponentów zależy od konfiguracji uwierzytelniania. Przykładowo w aplikacji wykorzystującej Form Login nieuwierzytelniony użytkownik może zostać przekierowany na stronę logowania zamiast otrzymać kod 401.

Podsumowanie

Spring Security to rozbudowany framework, który dostarcza gotowe mechanizmy zabezpieczania aplikacji Java. Dzięki architekturze opartej na filtrach umożliwia kontrolowanie dostępu do zasobów, uwierzytelnianie użytkowników oraz zarządzanie ich uprawnieniami.

Poznaliśmy najważniejsze komponenty Spring Security, takie jak SecurityFilterChain, AuthenticationManager, UserDetailsService i SecurityContextHolder. Omówiliśmy również uwierzytelnianie za pomocą HTTP Basic i formularza logowania, autoryzację opartą na rolach oraz wykorzystanie JWT do zabezpieczania REST API.

Spring Security oferuje także mechanizmy ochrony przed popularnymi zagrożeniami, takimi jak CSRF, oraz integrację z testami automatycznymi.

Dzięki elastycznej konfiguracji Spring Security możemy dostosować sposób zabezpieczania aplikacji do jej architektury i wymagań, bez konieczności implementowania podstawowych mechanizmów bezpieczeństwa od podstaw.

Źródła:

Spring Security – Architecture

Spring Security – Authentication Architecture

Spring Security – Authorize HTTP Requests

Spring Security – OAuth2 Resource Server JWT

Dodaj komentarz