Spring Security 6 och JWT-autentisering · Lektion

Säkerhetshärdning för produktion

Tillämpa viktiga säkerhetskonfigurationer och metoder för att härda din Spring Security-applikation inför en produktionsmiljö.

Lektion 1 av 411 steg

Säkerhetshärdning för produktion är en gratis lektion i Spring Security 6 och JWT-autentisering på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Spring Security 6 och JWT-autentisering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Security 6 och JWT-autentisering innehåller totalt 4 lektioner.

Introduktion till härdning för produktion

Välkommen till härdning av säkerheten för produktion! Att säkra en applikation under utveckling är en sak, men produktionsmiljöer kräver betydligt större vaksamhet.

I den här lektionen utforskar vi viktiga konfigurationer och bästa praxis för att skydda Er Spring Security-applikation när den tas i drift.

Det handlar inte bara om att åtgärda buggar, utan om att bygga ett robust försvar mot hot i verkligheten.

Varför HTTPS inte är förhandlingsbart

I produktion måste all kommunikation krypteras mellan klienter och Er server med HTTPS (HTTP Secure).

Datakonfidentialitet: Skyddar känsliga uppgifter (lösenord och personuppgifter) mot avlyssning.
Dataintegritet: Säkerställer att data inte manipuleras under överföringen.
Autentisering: Verifierar serverns identitet för klienten.

Utan HTTPS är Er applikation sårbar för Man-in-the-Middle-attacker (MITM).

Tvinga fram HTTPS med Spring Security

Spring Security kan tvinga alla förfrågningar att använda en säker kanal (HTTPS). Om en HTTP-förfrågan kommer in omdirigeras den till HTTPS (om Er server är konfigurerad för SSL).

Metoden requiresSecure() säkerställer detta. Försök köra denna minimala Spring Boot-applikation och observera dess beteende när Ni försöker komma åt den via HTTP (till exempel http://localhost:8080).

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@SpringBootApplication
public class HardeningApp {
    public static void main(String[] args) {
        SpringApplication.run(HardeningApp.class, args);
    }

    @Configuration
    @EnableWebSecurity
    static class SecurityConfig {

        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .anyRequest().authenticated()
                )
                .requiresChannel(channel -> channel
                    .anyRequest().requiresSecure() // Enforce HTTPS
                )
                .formLogin(); // Basic form login for testing
            return http.build();
        }

        @Bean
        public UserDetailsService userDetailsService() {
            UserDetails user = User.withDefaultPasswordEncoder()
                .username("user")
                .password("password")
                .roles("USER")
                .build();
            return new InMemoryUserDetailsManager(user);
        }
    }
}

Översikt över säkerhetsheaders

HTTP-säkerhetsheaders är avgörande för att förhindra vanliga sårbarheter i webben. De instruerar webbläsare om hur de ska agera när de interagerar med Er applikation.

Viktiga headers att konfigurera:

HSTS (Strict-Transport-Security): Tvingar webbläsare att använda HTTPS vid framtida besök.
CSP (Content-Security-Policy): Förhindrar XSS-attacker genom att begränsa innehållskällor.
X-Frame-Options: Förhindrar clickjacking genom att styra om Er webbplats får bäddas in i en iframe.
X-Content-Type-Options: Förhindrar MIME-sniffing-attacker.
Referrer-Policy: Styr hur mycket hänvisarinformation som skickas.

Konfigurera säkerhetsheaders

Spring Security tillhandahåller praktiska metoder för att konfigurera dessa headers via HttpSecurity.headers(). Detta säkerställer att Er applikations svar alltid innehåller dessa viktiga instruktioner för klientens webbläsare.

Så här kan Ni konfigurera några vanliga säkerhetsheaders:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.header.writers.ReferrerPolicyHeaderWriter;

@SpringBootApplication
public class HeaderApp {
    public static void main(String[] args) {
        SpringApplication.run(HeaderApp.class, args);
    }

    @Configuration
    @EnableWebSecurity
    static class SecurityConfig {

        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .anyRequest().authenticated()
                )
                .headers(headers -> headers
                    .httpStrictTransportSecurity(hsts -> hsts
                        .includeSubDomains(true)
                        .maxAgeInSeconds(31536000) // 1 year
                    )
                    .contentSecurityPolicy(csp -> csp
                        .policyDirectives("default-src 'self'; script-src 'self' 'unsafe-inline'; object-src 'none'")
                    )
                    .frameOptions(frameOptions -> frameOptions.deny()) // X-Frame-Options: DENY
                    .xContentTypeOptions() // X-Content-Type-Options: nosniff
                    .referrerPolicy(referrer -> referrer
                        .policy(ReferrerPolicyHeaderWriter.ReferrerPolicy.NO_REFERRER)
                    )
                )
                .formLogin();
            return http.build();
        }

        @Bean
        public UserDetailsService userDetailsService() {
            UserDetails user = User.withDefaultPasswordEncoder()
                .username("user")
                .password("password")
                .roles("USER")
                .build();
            return new InMemoryUserDetailsManager(user);
        }
    }
}

Inaktivera känsliga endpoints

I produktion bör Ni inaktivera eller begränsa åtkomsten till alla endpoints som kan avslöja känslig information eller möjliggöra oavsiktlig styrning.

Actuator-endpoints: Spring Boot Actuator tillhandahåller användbar driftinformation (/actuator/**). I produktion bör Ni endast exponera nödvändiga endpoints (till exempel /health och /info) och skydda dem.
HTTP-metoderna TRACE/OPTIONS: Dessa metoder kan ibland utnyttjas för informationsläckor eller cross-site tracing-attacker. Det är ofta bäst att inaktivera dem.

Granska alltid vad som exponeras och säkerställ att det verkligen behövs och är skyddat.

Anpassad felhantering

Standardfelsidor i utvecklingsmiljöer kan exponera stackspår och interna serverdetaljer, vilket är värdefull information för angripare.

I produktion bör Ni konfigurera anpassade felsidor som visar minimal information. Till exempel ett enkelt meddelande som ”Fel 500 – Internt serverfel” utan detaljer.

Med Spring Boot kan Ni definiera anpassade felsidor (till exempel src/main/resources/public/error.html eller src/main/resources/templates/error/404.html för specifika statuskoder).

Säker sessionshantering

Sessionscookies är avgörande för att bevara användarens tillstånd och behöver därför ett robust skydd. Spring Security hjälper till med detta, men Ni kan förstärka skyddet ytterligare.

HttpOnly: Förhindrar skript på klientsidan från att komma åt cookien.
Secure: Säkerställer att cookien endast skickas via HTTPS.
SameSite: Minskar risken för CSRF-attacker genom att begränsa när cookies skickas med förfrågningar mellan olika webbplatser (Lax eller Strict).

Dessa inställningar konfigureras ofta i application.properties, men Spring Securitys sessionManagement() erbjuder också motsvarande styrning.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@SpringBootApplication
public class SessionApp {
    public static void main(String[] args) {
        SpringApplication.run(SessionApp.class, args);
    }

    @Configuration
    @EnableWebSecurity
    static class SecurityConfig {

        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .anyRequest().authenticated()
                )
                .sessionManagement(session -> session
                    .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED) // Default, but good to be explicit
                    .sessionFixation().migrateSession() // Protects against session fixation attacks
                )
                .csrf(csrf -> csrf.disable()) // CSRF is enabled by default, disable for simplicity in this example
                .formLogin();
            return http.build();
        }

        @Bean
        public UserDetailsService userDetailsService() {
            UserDetails user = User.withDefaultPasswordEncoder()
                .username("user")
                .password("password")
                .roles("USER")
                .build();
            return new InMemoryUserDetailsManager(user);
        }
    }
}

Säker hantering av hemligheter

Hårdkoda aldrig känslig information (hemligheter), till exempel databasuppgifter, API-nycklar eller krypteringsnycklar, direkt i Er kod eller konfigurationsfiler.

Bästa praxis för hantering av hemligheter i produktion:

Miljövariabler: Läs in hemligheter från miljövariabler.
Extern konfiguration: Använd Spring Cloud Config Server eller liknande verktyg.
Dedikerade tjänster för hemlighetshantering: HashiCorp Vault, AWS Secrets Manager och Azure Key Vault är utformade för detta ändamål.

Detta förhindrar att hemligheter exponeras i källkodshantering eller byggartefakter.

Kontroll av härdning för produktion

Vilka av följande är rekommenderade metoder för att härda en Spring Security-applikation i en produktionsmiljö? Välj alla som gäller.

Besvara frågan i den interaktiva lektionen

Sammanfattning och nästa steg

Utmärkt arbete! Ni har lärt Er viktiga steg för att härda Er Spring Security-applikation för produktion.

Vi har gått igenom:

Varför HTTPS behövs och hur det tvingas fram.
Konfiguration av viktiga HTTP-säkerhetsheaders.
Begränsning av känsliga endpoints och tillhandahållande av anpassade felsidor.
Implementering av säker sessionshantering.
Bästa praxis för hantering av hemligheter.

Dessa metoder utgör en stark grund för en säker driftsättning. Därefter går vi igenom loggning och övervakning av säkerhetshändelser för att effektivt upptäcka och hantera hot.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Säkerhetshärdning för produktion” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Spring Security 6 och JWT-autentisering, inklusive ”Säkerhetshärdning för produktion”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Spring Security 6 och JWT-autentisering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Säkerhetshärdning för produktion”?

Tillämpa viktiga säkerhetskonfigurationer och metoder för att härda din Spring Security-applikation inför en produktionsmiljö. Ni övar på Spring Security 6 och JWT-autentisering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Security 6 och JWT-autentisering?

Du behöver inga förkunskaper. Utbildningen i Spring Security 6 och JWT-autentisering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Säkerhetshärdning för produktion”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Security 6 och JWT-autentisering-lektionen?

Ja. Varje Spring Security 6 och JWT-autentisering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Säkerhetshärdning för produktion
Loggning och övervakning av säkerhetshändelser
Vanliga säkerhetssårbarheter och lösningar
Konfigurera säkerhetsheaders och HTTPS

← Tillbaka till Spring Security 6 och JWT-autentisering