Wie oauth2 Token vom Benutzer (authorization_code) in einer Ruhe Vorlage

Question

Ich habe 3 Anwendungen

1. Frontend-Anwendung
2. OAuth2 Authentifizierungsserver
3. REST-API (RepositoryRestResources)

wiederzuverwenden Meine Benutzer müssen sich anmelden, bevor sie die Frontend-Anwendung verwenden können. Dies geschieht durch SSO. Sie erhalten ein Token, das vom Kunden validiert wird, bevor es eingelassen wird.

Ich möchte dieses Token wiederverwenden, um API-Anfragen zu stellen. Meine REST-API-Anwendung ist mit demselben SSO-Login gesichert (es ist eine Ressource für den Frontend-Client), aber ich habe keine Ahnung, wie ich den Autorisierungsheader hinzufügen soll, der in der RestTemplate für API-Anfragen verwendet werden soll.

Ich eröffne mein restTemplate wie folgt aus:

public static RestTemplate build() 
    { 
     ObjectMapper mapper = new ObjectMapper(); 
     mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); 
     mapper.registerModule(new Jackson2HalModule()); 
     mapper.registerModule(new JavaTimeModule()); 
     MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(); 
     converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json")); 
     converter.setObjectMapper(mapper); 
     return new RestTemplate(Arrays.asList(converter)); 
    } 

meine Ressource-Server-Konfiguration:

@Configuration 
@EnableResourceServer 
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter 
{ 

    @Value("${resource.id}") 
    private String resourceId; 

    @Override 
    public void configure(HttpSecurity http) throws Exception 
    { 
     http 
       .authorizeRequests() 
       .antMatchers(HttpMethod.OPTIONS).permitAll() 
       .anyRequest().authenticated() 
       .and().exceptionHandling().accessDeniedHandler(new OAuth2AccessDeniedHandler()); 
    } 

    @Override 
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception 
    { 
     resources.resourceId(resourceId); 
    } 


    @Bean 
    public static TokenEnhancer tokenEnhancer() 
    { 
     return new JwtTokenEnhancer(); 
    } 


    @Bean 
    public static JwtAccessTokenConverter accessTokenConverter() 
    { 
     KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("keystore.jks"), "somesecret".toCharArray()); 
     JwtAccessTokenConverter converter = new JwtAccessTokenConverter(); 

     converter.setKeyPair(keyStoreKeyFactory.getKeyPair("pair")); 
     return converter; 
    } 

    @Bean 
    public static TokenStore tokenStore() 
    { 
     return new JwtTokenStore(accessTokenConverter()); 
    } 

} 

Answer 1

ich es eine feste intercepter unter Verwendung eines manuell das Token aus dem Sicherheitskontext hinzufügen.

RestTemplate restTemplate = new RestTemplate(); 
restTemplate.getInterceptors().add(new OAuthInterceptor()); 

In dem die intercepter wie folgt definiert:

public class OAuthInterceptor implements ClientHttpRequestInterceptor 
{ 

    @Autowired 
    private AuthenticationHolder holder; 

    @Override 
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException 
    { 
     if (holder.getToken() == null) 
     { 
      //throw new IOException("Token not set"); 
      System.out.println("##################### Token not set! ###################"); 
     } 
     else 
     { 
      System.out.println("##################### Token found: " + holder.getToken()); 
      HttpHeaders headers = request.getHeaders(); 
      headers.add(HttpHeaders.AUTHORIZATION, "Bearer " + holder.getToken()); 
     } 

     return execution.execute(request, body); 
    } 
} 

ich eine Schnittstelle verwenden, die ich in meinem Client-Anwendung implementieren:

public interface AuthenticationHolder 
{ 
    String getToken(); 
} 

@Bean 
public AuthenticationHolder getAuthenticationHolder() 
{ 
    return() -> 
    { 
     Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); 
     if(authentication != null && authentication.getDetails() instanceof OAuth2AuthenticationDetails) 
     { 
      return ((OAuth2AuthenticationDetails) authentication.getDetails()).getTokenValue(); 
     } 
     return null; 
    }; 
} 

Answer 2

Sie die @PreAuthorize(ROLE) auf der Oberseite Ihrer Methoden verwenden können, so dass, wenn diese Methode aufgerufen wird, er wird Wie für das Token wird er dann prüfen, ob das bereitgestellte Token die notwendige ROLE hat, um die Methode zu verwenden.

Natürlich müssen Sie Ihre API für die Verbindung mit Ihrer OAuth-Datenbank konfigurieren.

Beispiel:

@PreAuthorize("ROLE_ADMIN") public void deleteAll(){ ... }