WebSockets och realtidssystem med Spring · Lektion

Integrering med Spring Security

Integrera Spring Security för att skydda WebSocket-anslutningar och meddelandeflöden.

Lektion 2 av 411 steg

Integrering med Spring Security är en gratis lektion i WebSockets och realtidssystem med Spring på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för WebSockets och realtidssystem med Spring, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.

Skydda dina realtidsappar

Det är spännande att integrera realtidsfunktioner som WebSockets i dina applikationer, men säkerheten är avgörande. Precis som traditionella HTTP-endpoints behöver dina WebSocket-anslutningar och meddelandeflöden skyddas.

Dataintegritet: Förhindra obehörig manipulering av meddelanden.
Konfidentialitet: Säkerställ att endast behöriga användare kan läsa känsliga data.
Åtkomstkontroll: Kontrollera vem som får ansluta, skicka meddelanden eller prenumerera på topics.

Spring Security erbjuder ett kraftfullt ramverk för att effektivt skydda dina WebSocket-endpoints.

Viktiga säkerhetsberoenden

För att börja säkra din Spring WebSocket-applikation behöver du lägga till de nödvändiga Spring Security-beroendena i projektet. Om du använder Spring Boot är detta vanligtvis enkelt.

Du behöver framför allt:

spring-boot-starter-security: Tillhandahåller grundläggande funktioner i Spring Security.
spring-security-messaging: Specifikt för att skydda Springs meddelandeinfrastruktur, inklusive WebSockets och STOMP.

Om du använde Spring Initializr ska du kontrollera att dessa finns med i din pom.xml (Maven) eller build.gradle (Gradle).

Grunden för HTTP-säkerhet

WebSocket-anslutningar börjar vanligtvis med en HTTP-handskakning. Det innebär att din befintliga HTTP-säkerhetskonfiguration i Spring Security utgör grunden för WebSocket-säkerheten.

Innan meddelanden skickas via WebSockets autentiseras användaren vanligtvis genom en vanlig HTTP-inloggning. Spring Security använder sedan den autentiserade sessionen för att skydda efterföljande WebSocket-interaktioner. En minimal HTTP-säkerhetskonfiguration kan se ut så här:

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  http
    .authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
    .formLogin(withDefaults());
  return http.build();
}

Detta säkerställer att alla HTTP-förfrågningar kräver autentisering, vilket är avgörande för WebSocket-handskakningen.

Aktivera WebSocket-säkerhet

När du har infört den grundläggande HTTP-säkerheten behöver du tala om för Spring Security att WebSocket-meddelandena ska skyddas. Det gör du genom att lägga till annoteringen @EnableWebSocketSecurity.

Vanligtvis placerar du denna annotering på en konfigurationsklass som utökar WebSocketMessageBrokerConfigurer. Då kan du anpassa både WebSocket-meddandemäklaren och dess säkerhetsregler i en och samma konfiguration.

Annoteringen @EnableWebSocketSecurity aktiverar Spring Securitys meddelandebaserade auktorisering för STOMP-meddelanden, så att du kan definiera detaljerad åtkomstkontroll.

Skydda STOMP-destinationer

Spring Security integreras med STOMP-protokollet, vilket gör att du kan skydda specifika meddelandedestinationer. Det gör du genom att åsidosätta metoden configureInbound() i din WebSocketMessageBrokerConfigurer.

I den här metoden använder du en MessageSecurityMetadataSourceRegistry för att definiera regler baserade på destinationsmönster:

.simpDestMatchers("/app/private-chat").authenticated(): Endast autentiserade användare kan skicka meddelanden till denna destination.
.simpDestMatchers("/topic/admin-updates").hasRole("ADMIN"): Endast användare med rollen 'ADMIN' kan prenumerera på detta topic.

Detta ger kraftfull, URL-liknande säkerhet för dina realtidsmeddelanden.

Användaridentitet i WebSockets

En viktig fördel med att integrera Spring Security är hur användarautentisering hanteras. När en användare ansluter till en WebSocket-endpoint efter att ha autentiserats via HTTP kopplar Spring Security automatiskt användarens Principal (användaridentitet) till WebSocket-sessionen.

Det innebär att alla säkerhetsregler du definierar för WebSocket-meddelanden kan använda samma autentiserings- och auktoriseringskontext som dina vanliga HTTP-förfrågningar. Du behöver inte autentisera användarna på nytt separat för WebSockets.

Objektet Principal finns tillgängligt i WebSocket-sessionen, vilket gör att du kan fatta auktoriseringsbeslut baserat på den autentiserade användarens roller eller uppgifter.

Styrning av meddelandesändning

Du kan definiera auktoriseringsregler för meddelanden som klienter skickar till servern (till exempel publicering till en /app-destination). Detta görs med .simpMessageSending() i MessageSecurityMetadataSourceRegistry.

Om du till exempel bara vill tillåta autentiserade användare att skicka meddelanden:

messages.simpMessageSending().authenticated();

Eller om du vill begränsa sändningen till en specifik roll:

messages.simpMessageSending().hasRole("USER");

Detta säkerställer att endast behöriga klienter kan publicera meddelanden till applikationens interna hanterare.

Begränsa prenumerationer

Det är lika viktigt att kontrollera vem som får prenumerera på ett visst topic. Du kan använda .simpSubscribe() i MessageSecurityMetadataRegistry för att tillämpa auktoriseringsregler på prenumerationsförfrågningar.

Du kan till exempel tillåta vem som helst att prenumerera på ett offentligt topic, men bara administratörer på ett privat:

messages
  .simpSubscribeDestMatchers("/topic/public").permitAll()
  .simpSubscribeDestMatchers("/topic/private-admin").hasRole("ADMIN");

Detta hindrar obehöriga användare från att ta emot meddelanden som är avsedda för specifika grupper eller roller.

Exempel: Skydda destinationer

Vi ska titta på en minimal Spring Boot-applikation som integrerar Spring Security för att skydda WebSocket STOMP-destinationer. I exemplet definieras olika åtkomstregler för offentliga kanaler, adminkanaler och kanaler som endast autentiserade användare får använda.

När applikationen startar aktiverar den WebSocket-säkerhet och konfigurerar regler för sändning och prenumeration på specifika sökvägar. I en riktig applikation behöver du även en HTTP-säkerhetskonfiguration (som nämndes i scen 3) och en användartjänst för autentisering.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.messaging.MessageSecurityMetadataSourceRegistry;
import org.springframework.security.config.annotation.web.socket.EnableWebSocketSecurity;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;

@SpringBootApplication
@EnableWebSocketMessageBroker // Enables STOMP over WebSockets
@EnableWebSocketSecurity // Enables Spring Security for WebSocket messages
@Configuration
public class Main implements WebSocketMessageBrokerConfigurer {

  public static void main(String[] args) {
    SpringApplication.run(Main.class, args);
    System.out.println("WebSocket Security Demo Started!");
    System.out.println("Access at ws://localhost:8080/ws");
  }

  // Configure STOMP endpoints (e.g., /ws)
  @Override
  public void registerStompEndpoints(StompEndpointRegistry registry) {
    registry.addEndpoint("/ws").withSockJS();
  }

  // Configure message broker (e.g., /topic, /app)
  @Override
  public void configureMessageBroker(MessageBrokerRegistry registry) {
    registry.enableSimpleBroker("/topic", "/queue");
    registry.setApplicationDestinationPrefixes("/app");
  }

  // Configure message security rules for inbound messages
  @Override
  protected void configureInbound(MessageSecurityMetadataSourceRegistry messages) {
    messages
      // Allow anyone to subscribe to /topic/public
      .simpSubscribeDestMatchers("/topic/public").permitAll()
      // Only ADMIN role can subscribe to /topic/admin
      .simpSubscribeDestMatchers("/topic/admin").hasRole("ADMIN")
      // Authenticated users can send messages to /app/private
      .simpDestMatchers("/app/private").authenticated()
      // Deny all other message types/destinations by default
      .anyMessage().denyAll();
  }
}

Konfigurera åtkomst

Föreställ dig att du bygger en realtidsapplikation med chattrum. Du behöver konfigurera följande säkerhetsregler för dina STOMP-meddelanden:

Klienter får endast skicka meddelanden till /app/general-chat om de är autentiserade.
Endast användare med rollen MODERATOR får prenumerera på /topic/moderator-alerts.
Alla andra meddelandetyper eller destinationer som inte uttryckligen har tillåtits ska nekas som standard.

Vilka Spring Security-regler skulle du tillämpa bland alternativen nedan?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Skydda dina realtidsappar

Du har lärt dig att integrera Spring Security med dina WebSocket-applikationer för att skydda realtidskommunikation. Här är en kort sammanfattning:

Lägg till beroendena spring-boot-starter-security och spring-security-messaging.
Se till att det finns en grundläggande HTTP-säkerhetskonfiguration, eftersom WebSocket-säkerheten bygger på den.
Använd @EnableWebSocketSecurity för att aktivera säkerhet på meddelandenivå.
Åsidosätt configureInbound() i WebSocketMessageBrokerConfigurer för att definiera regler.
Använd MessageSecurityMetadataSourceRegistry tillsammans med .simpDestMatchers(), .simpMessageSending() och .simpSubscribeDestMatchers() för att tillämpa auktorisering.
Använd .authenticated(), .hasRole() och .permitAll(), tillsammans med .anyMessage().denyAll(), för en robust säkerhetsnivå.

Genom att följa dessa steg kan du säkerställa att dina realtidsapplikationer är säkra och tillförlitliga!

Gratis att börja

Lär dig WebSockets och realtidssystem med Spring 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 ”Integrering med Spring Security” gratis?

Ja – hela texten till ”Integrering med Spring Security” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i WebSockets och realtidssystem med Spring, kan Ni uppgradera till CoddyKit PRO. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.

Vad lär jag mig i ”Integrering med Spring Security”?

Integrera Spring Security för att skydda WebSocket-anslutningar och meddelandeflöden. Ni övar på WebSockets och realtidssystem med Spring 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 WebSockets och realtidssystem med Spring?

Du behöver inga förkunskaper. Utbildningen i WebSockets och realtidssystem med Spring 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 2 av 4.

Hur lång tid tar lektionen ”Integrering med Spring Security”?

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 WebSockets och realtidssystem med Spring-lektionen?

Ja. Varje WebSockets och realtidssystem med Spring-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

← Tillbaka till WebSockets och realtidssystem med Spring