Текущая Ситуация

обновление 2016-12-13: проблема, на которую ссылается ниже, Теперь отмечена исправлена, поэтому Хак ниже больше не нужен, который весной 4.3.5 или выше. Смотри https://github.com/spring-projects/spring-framework/blob/master/src/docs/asciidoc/web/web-websocket.adoc#token-based-authentication.

Предыдущие Ситуации

в настоящее время (Sep 2016), это не поддерживается Spring, за исключением параметра запроса как ответил @Россен-stoyanchev, кто пишет много (все?) поддержки весеннего WebSocket. Мне не нравится подход параметров запроса из-за потенциальной утечки http-реферера и хранения токена в журналах сервера. Кроме того, если вас не беспокоят последствия безопасности, обратите внимание, что я обнаружил, что этот подход работает для истинных соединений WebSocket,но если вы используете SockJS с обратными связями с другими механизмами,determineUser метод никогда не вызывается для резервного. Видеть Весна 4.X маркер на основе WebSocket SockJS резервная аутентификация.

я создал весеннюю проблему для улучшения поддержки аутентификации WebSocket на основе токенов:https://jira.spring.io/browse/SPR-14690

Взлома

тем временем, я нашел хак, который хорошо работает в тестировании. Обойдите встроенное машинное оборудование auth весны соединени-уровня весны. Вместо этого установите маркер проверки подлинности на уровне сообщений, отправив это в заголовках Stomp на стороне клиента (это красиво отражает то, что вы уже делаете с регулярными вызовами HTTP XHR), например:

stompClient.connect({'X-Authorization': 'token'}, ...);
stompClient.subscribe(..., {'X-Authorization': 'token'});
stompClient.send("/wherever", {'X-Authorization': 'token'}, ...);

на стороне сервера получите токен из сообщения Stomp с помощью ChannelInterceptor

@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
  registration.setInterceptors(new ChannelInterceptorAdapter() {
     Message<*> preSend(Message<*> message,  MessageChannel channel) {
      StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
      List tokenList = accessor.getNativeHeader("X-Authorization");
      String token = null;
      if(tokenList == null || tokenList.size < 1) {
        return message;
      } else {
        token = tokenList.get(0);
        if(token == null) {
          return message;
        }
      }

      // validate and convert to a Principal based on your own requirements e.g.
      // authenticationManager.authenticate(JwtAuthentication(token))
      Principal yourAuth = [...];

      accessor.setUser(yourAuth);

      // not documented anywhere but necessary otherwise NPE in StompSubProtocolHandler!
      accessor.setLeaveMutable(true);
      return MessageBuilder.createMessage(message.payload, accessor.messageHeaders)
    }
  })

это просто и дает нам 85% пути туда, однако, этот подход не поддерживает отправку сообщений конкретным пользователям. Это связано с тем, что механизм Spring для связывания пользователей с сеансами не зависит от результата ChannelInterceptor. Spring WebSocket предполагает, что аутентификация выполняется на транспортном уровне, а не на уровне сообщений, и поэтому игнорирует аутентификацию на уровне сообщений.

хак, чтобы сделать эту работу в любом случае, чтобы создать наши экземпляры DefaultSimpUserRegistry и DefaultUserDestinationResolver, подвергните их воздействию окружающей среды, а затем используйте перехватчик для обновления, как будто это делает сама весна. Другими словами, что-то типа:

@Configuration
@EnableWebSocketMessageBroker
@Order(HIGHEST_PRECEDENCE + 50)
class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer() {
  private DefaultSimpUserRegistry userRegistry = new DefaultSimpUserRegistry();
  private DefaultUserDestinationResolver resolver = new DefaultUserDestinationResolver(userRegistry);

  @Bean
  @Primary
  public SimpUserRegistry userRegistry() {
    return userRegistry;
  }

  @Bean
  @Primary
  public UserDestinationResolver userDestinationResolver() {
    return resolver;
  }


  @Override
  public configureMessageBroker(MessageBrokerRegistry registry) {
    registry.enableSimpleBroker("/queue", "/topic");
  }

  @Override
  public registerStompEndpoints(StompEndpointRegistry registry) {
    registry
      .addEndpoint("/stomp")
      .withSockJS()
      .setWebSocketEnabled(false)
      .setSessionCookieNeeded(false);
  }

  @Override public configureClientInboundChannel(ChannelRegistration registration) {
    registration.setInterceptors(new ChannelInterceptorAdapter() {
       Message<*> preSend(Message<*> message,  MessageChannel channel) {
        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);

        List tokenList = accessor.getNativeHeader("X-Authorization");
        accessor.removeNativeHeader("X-Authorization");

        String token = null;
        if(tokenList != null && tokenList.size > 0) {
          token = tokenList.get(0);
        }

        // validate and convert to a Principal based on your own requirements e.g.
        // authenticationManager.authenticate(JwtAuthentication(token))
        Principal yourAuth = token == null ? null : [...];

        if (accessor.messageType == SimpMessageType.CONNECT) {
          userRegistry.onApplicationEvent(SessionConnectedEvent(this, message, yourAuth));
        } else if (accessor.messageType == SimpMessageType.SUBSCRIBE) {
          userRegistry.onApplicationEvent(SessionSubscribeEvent(this, message, yourAuth));
        } else if (accessor.messageType == SimpMessageType.UNSUBSCRIBE) {
          userRegistry.onApplicationEvent(SessionUnsubscribeEvent(this, message, yourAuth));
        } else if (accessor.messageType == SimpMessageType.DISCONNECT) {
          userRegistry.onApplicationEvent(SessionDisconnectEvent(this, message, accessor.sessionId, CloseStatus.NORMAL));
        }

        accessor.setUser(yourAuth);

        // not documented anywhere but necessary otherwise NPE in StompSubProtocolHandler!
        accessor.setLeaveMutable(true);
        return MessageBuilder.createMessage(message.payload, accessor.messageHeaders);
      }
    })
  }
}

теперь Spring полностью осознает аутентификацию, т. е. он вводит Principal в любые методы контроллера, которые требуют этого, предоставляет его контексту для Spring Security 4.x и связывает пользователя с сеансом WebSocket для отправки сообщений определенным пользователям / сеансам.

Spring Security Messaging

наконец, если вы используете Spring Security 4.X поддержка обмена сообщениями, убедитесь, что установить @Order вашего AbstractWebSocketMessageBrokerConfigurer к более высокому значению, чем Spring Security AbstractSecurityWebSocketMessageBrokerConfigurer (Ordered.HIGHEST_PRECEDENCE + 50 будет работать, как показано выше). Таким образом, перехватчик устанавливает Principal перед Spring Security выполняет свою проверку и устанавливает контекст безопасности.

создание участника (обновление июнь 2018)

многие люди, похоже, смущены этой строкой в коде выше:

  // validate and convert to a Principal based on your own requirements e.g.
  // authenticationManager.authenticate(JwtAuthentication(token))
  Principal yourAuth = [...];

это в значительной степени выходит за рамки вопроса, поскольку он не специфичен для Stomp, но я все равно немного расширю его, потому что он связан с использованием токенов auth с Spring. При использовании проверки подлинности на основе маркеров Principal вам нужно будет настраиваемой JwtAuthentication класс, который расширяет Spring Security в AbstractAuthenticationToken класса. AbstractAuthenticationToken осуществляет Authentication интерфейс, который расширяет Principal интерфейс и содержит большую часть оборудования для интеграции вашего токена с Spring Security.

Итак, в коде Котлина (извините, у меня нет времени или склонности переводить это обратно на Java), ваш JwtAuthentication может выглядеть примерно так, что это простая обертка вокруг AbstractAuthenticationToken:

import my.model.UserEntity
import org.springframework.security.authentication.AbstractAuthenticationToken
import org.springframework.security.core.GrantedAuthority

class JwtAuthentication(
  val token: String,
  // UserEntity is your application's model for your user
  val user: UserEntity? = null,
  authorities: Collection<GrantedAuthority>? = null) : AbstractAuthenticationToken(authorities) {

  override fun getCredentials(): Any? = token

  override fun getName(): String? = user?.id

  override fun getPrincipal(): Any? = user
}

и AuthenticationManager это знает, как справиться с этим. Это может выглядеть примерно следующим образом, снова в Котлине:

@Component
class CustomTokenAuthenticationManager @Inject constructor(
  val tokenHandler: TokenHandler,
  val authService: AuthService) : AuthenticationManager {

  val log = logger()

  override fun authenticate(authentication: Authentication?): Authentication? {
    return when(authentication) {
      // for login via username/password e.g. crash shell
      is UsernamePasswordAuthenticationToken -> {
        findUser(authentication).let {
          //checkUser(it)
          authentication.withGrantedAuthorities(it).also { setAuthenticated(true) }
        }
      }
      // for token-based auth
      is JwtAuthentication -> {
        findUser(authentication).let {
          val tokenTypeClaim = tokenHandler.parseToken(authentication.token)[CLAIM_TOKEN_TYPE]
          when(tokenTypeClaim) {
            TOKEN_TYPE_ACCESS -> {
              //checkUser(it)
              authentication.withGrantedAuthorities(it).also { setAuthenticated(true) }
            }
            TOKEN_TYPE_REFRESH -> {
              //checkUser(it)
              JwtAuthentication(authentication.token, it, listOf(SimpleGrantedAuthority(Authorities.REFRESH_TOKEN)))
            }
            else -> throw IllegalArgumentException("Unexpected token type claim $tokenTypeClaim.")
          }
        }
      }
      else -> null
    }
  }

  private fun findUser(authentication: JwtAuthentication): UserEntity =
    authService.login(authentication.token) ?:
      throw BadCredentialsException("No user associated with token or token revoked.")

  private fun findUser(authentication: UsernamePasswordAuthenticationToken): UserEntity =
    authService.login(authentication.principal.toString(), authentication.credentials.toString()) ?:
      throw BadCredentialsException("Invalid login.")

  @Suppress("unused", "UNUSED_PARAMETER")
  private fun checkUser(user: UserEntity) {
    // TODO add these and lock account on x attempts
    //if(!user.enabled) throw DisabledException("User is disabled.")
    //if(user.accountLocked) throw LockedException("User account is locked.")
  }

  fun JwtAuthentication.withGrantedAuthorities(user: UserEntity): JwtAuthentication {
    return JwtAuthentication(token, user, authoritiesOf(user))
  }

  fun UsernamePasswordAuthenticationToken.withGrantedAuthorities(user: UserEntity): UsernamePasswordAuthenticationToken {
    return UsernamePasswordAuthenticationToken(principal, credentials, authoritiesOf(user))
  }

  private fun authoritiesOf(user: UserEntity) = user.authorities.map(::SimpleGrantedAuthority)
}

впрыснутый TokenHandler абстрагирует разбор токена JWT, но должен использовать общую библиотеку токенов JWT, такую как jjwt. Впрыснутый AuthService - это абстракция, которая на самом деле создает свой UserEntity на основе утверждений в токене и может разговаривать с вашей базой данных Пользователя или другим бэкэндом система(ы).

теперь, возвращаясь к линии, с которой мы начали, это может выглядеть примерно так, где authenticationManager это AuthenticationManager впрыснутый в наш переходнику весной, и экземпляр CustomTokenAuthenticationManager мы определили выше:

Principal yourAuth = token == null ? null : authenticationManager.authenticate(new JwtAuthentication(token));

этот Принципал затем присоединяется к сообщению, как описано выше. НТН!

С последним SockJS 1.0.3 вы можете передавать параметры запроса как часть URL-адреса соединения. Таким образом, вы можете отправить токен JWT для авторизации сеанса.

  var socket = new SockJS('http://localhost/ws?token=AAA');
  var stompClient = Stomp.over(socket);
  stompClient.connect({}, function(frame) {
      stompClient.subscribe('/topic/echo', function(data) {
        // topic handler
      });
    }
  }, function(err) {
    // connection error
  });

теперь все запросы, связанные с websocket, будут иметь параметр "?token=AAA"

http://localhost/ws/info?токен=AAA&t=1446482506843

http://localhost/ws/515/z45wjz24/websocket?токен=AAA

затем с помощью Spring вы можете настроить некоторый фильтр, который будет определите сеанс, используя предоставленный токен.