WebSockets og sanntidssystemer med Spring · leksjon

Integrering med Spring Security

Integrer Spring Security for å beskytte WebSocket-tilkoblinger og meldingsflyt.

Leksjon 2 av 411 trinn

Integrering med Spring Security er en gratis leksjon i WebSockets og sanntidssystemer med Spring på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i WebSockets og sanntidssystemer med Spring, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Sikre sanntidsapplikasjonene Deres

Det er spennende å integrere sanntidsfunksjoner som WebSocket i applikasjonene Deres, men sikkerhet er avgjørende. Akkurat som tradisjonelle HTTP-endepunkter må WebSocket-tilkoblingene og meldingsflyten beskyttes.

Dataintegritet: Forhindre uautoriserte endringer i meldinger.
Konfidensialitet: Sørg for at bare autoriserte brukere kan lese sensitive data.
Tilgangskontroll: Kontroller hvem som kan koble til, sende meldinger eller abonnere på emner.

Spring Security tilbyr et kraftig rammeverk for å sikre WebSocket-endepunktene Deres effektivt.

Nødvendige sikkerhetsavhengigheter

For å begynne å sikre Spring WebSocket-applikasjonen Deres må De legge til de nødvendige Spring Security-avhengighetene i prosjektet. Hvis De bruker Spring Boot, er dette vanligvis enkelt.

De trenger hovedsakelig:

spring-boot-starter-security: Tilbyr grunnleggende funksjoner i Spring Security.
spring-security-messaging: Er spesielt beregnet på å sikre Spring-infrastrukturen for meldinger, inkludert WebSocket og STOMP.

Hvis De brukte Spring Initializr, må De kontrollere at disse er inkludert i pom.xml (Maven) eller build.gradle (Gradle).

Grunnlaget for HTTP-sikkerhet

WebSocket-tilkoblinger starter vanligvis med et HTTP-håndtrykk. Det betyr at den eksisterende HTTP-sikkerhetskonfigurasjonen i Spring Security danner grunnlaget for WebSocket-sikkerheten.

Før meldinger sendes over WebSocket, autentiseres brukeren vanligvis gjennom en standard HTTP-påloggingsprosess. Spring Security bruker deretter denne autentiserte økten til å sikre videre WebSocket-kommunikasjon. Et minimalt HTTP-sikkerhetsoppsett kan se slik ut:

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

Dette sikrer at alle HTTP-forespørsler krever autentisering, noe som er avgjørende for WebSocket-håndtrykket.

Aktiver WebSocket-sikkerhet

Når De har konfigurert den grunnleggende HTTP-sikkerheten, må De fortelle Spring Security at WebSocket-meldingene skal sikres. Dette gjør De ved å legge til annoteringen @EnableWebSocketSecurity.

Vanligvis plasserer De denne annoteringen på en konfigurasjonsklasse som utvider WebSocketMessageBrokerConfigurer. Dermed kan De tilpasse både WebSocket-meldingsmegleren og sikkerhetsreglene i én enkelt konfigurasjon.

Annoteringen @EnableWebSocketSecurity aktiverer Spring Securitys meldingsbaserte autorisering for STOMP-meldinger, slik at De kan definere finmasket tilgangskontroll.

Sikring av STOMP-destinasjoner

Spring Security integreres med STOMP-protokollen, slik at De kan sikre bestemte meldingsdestinasjoner. Dette gjør De ved å overstyre metoden configureInbound() i WebSocketMessageBrokerConfigurer.

Inne i denne metoden bruker De en MessageSecurityMetadataSourceRegistry til å definere regler basert på destinasjonsmønstre:

.simpDestMatchers("/app/private-chat").authenticated(): Bare autentiserte brukere kan sende meldinger til denne destinasjonen.
.simpDestMatchers("/topic/admin-updates").hasRole("ADMIN"): Bare brukere med rollen «ADMIN» kan abonnere på dette emnet.

Dette gir kraftig, URL-lignende sikkerhet for sanntidsmeldingene Deres.

Brukeridentitet i WebSocket

En viktig fordel ved å integrere Spring Security er hvordan brukerautentisering håndteres. Når en bruker kobler til et WebSocket-endepunkt etter å ha autentisert seg via HTTP, knytter Spring Security automatisk brukerens Principal (brukeridentitet) til WebSocket-økten.

Det betyr at alle sikkerhetsregler De definerer for WebSocket-meldinger, kan bruke den samme autentiserings- og autoriseringskonteksten som de vanlige HTTP-forespørslene. De trenger ikke å autentisere brukerne på nytt for WebSocket.

Principal-objektet vil være tilgjengelig i WebSocket-økten, slik at De kan ta autoriseringsavgjørelser basert på den autentiserte brukerens roller eller detaljer.

Kontroller sending av meldinger

De kan definere autoriseringsregler for meldinger som klienter sender til serveren (for eksempel publisering til en /app-destinasjon). Dette gjør De ved å bruke .simpMessageSending() i MessageSecurityMetadataSourceRegistry.

For eksempel, for å tillate at bare autentiserte brukere sender meldinger:

messages.simpMessageSending().authenticated();

Eller for å begrense sending til en bestemt rolle:

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

Dette sikrer at bare autoriserte klienter kan publisere meldinger til applikasjonens interne behandlere.

Begrens abonnementer

Det er like viktig å kontrollere hvem som kan abonnere på et bestemt emne. De kan bruke .simpSubscribe() i MessageSecurityMetadataRegistry for å legge autoriseringsregler på abonnementsforespørsler.

For eksempel kan alle få abonnere på et offentlig emne, mens bare administratorer får abonnere på et privat emne:

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

Dette hindrer uautoriserte brukere i å motta meldinger som er ment for bestemte grupper eller roller.

Eksempel: Sikring av destinasjoner

La oss se på en minimal Spring Boot-applikasjon som integrerer Spring Security for å beskytte WebSocket-STOMP-destinasjoner. Dette eksempelet definerer ulike tilgangsregler for offentlige kanaler, administratorkanaler og kanaler som bare er tilgjengelige for autentiserte brukere.

Når applikasjonen starter, aktiverer den WebSocket-sikkerhet og konfigurerer regler for sending og abonnement på bestemte stier. I en virkelig applikasjon trenger De også en HTTP-sikkerhetskonfigurasjon (som nevnt i scene 3) og en brukertjeneste for 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();
  }
}

Konfigurer tilgang

Se for Dem at De bygger en sanntidsapplikasjon med chatterom. De må konfigurere følgende sikkerhetsregler for STOMP-meldingene:

Klienter kan bare sende meldinger til /app/general-chat hvis de er autentisert.
Bare brukere med rollen MODERATOR kan abonnere på /topic/moderator-alerts.
Alle andre meldingstyper eller destinasjoner som ikke er uttrykkelig tillatt, skal avvises som standard.

Hvilke Spring Security-regler ville De brukt fra alternativene nedenfor?

Besvar den i den interaktive leksjonen

Oppsummering: Sikre sanntidsapplikasjonene Deres

De har lært hvordan Spring Security integreres med WebSocket-applikasjoner for å beskytte sanntidskommunikasjon. Her er en kort oppsummering:

Legg til avhengighetene spring-boot-starter-security og spring-security-messaging.
Sørg for at det finnes en grunnleggende HTTP-sikkerhetskonfigurasjon, siden WebSocket-sikkerheten bygger på den.
Bruk @EnableWebSocketSecurity for å aktivere sikkerhet på meldingsnivå.
Overstyr configureInbound() i WebSocketMessageBrokerConfigurer for å definere regler.
Bruk MessageSecurityMetadataSourceRegistry med .simpDestMatchers(), .simpMessageSending() og .simpSubscribeDestMatchers() for å håndheve autorisering.
Bruk .authenticated(), .hasRole() og .permitAll(), sammen med .anyMessage().denyAll(), for en robust sikkerhetstilstand.

Ved å følge disse trinnene kan De sørge for at sanntidsapplikasjonene Deres er sikre og pålitelige!

Gratis å komme i gang

Lær deg WebSockets og sanntidssystemer med Spring med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrering med Spring Security» gratis?

Ja – hele teksten i «Integrering med Spring Security» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av WebSockets og sanntidssystemer med Spring-kurset, kan du oppgradere til CoddyKit PRO. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrering med Spring Security»?

Integrer Spring Security for å beskytte WebSocket-tilkoblinger og meldingsflyt. Du øver på WebSockets og sanntidssystemer med Spring med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med WebSockets og sanntidssystemer med Spring?

Ingen tidligere erfaring er nødvendig. WebSockets og sanntidssystemer med Spring på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Integrering med Spring Security»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne WebSockets og sanntidssystemer med Spring-leksjonen?

Ja. Alle WebSockets og sanntidssystemer med Spring-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til WebSockets og sanntidssystemer med Spring