Jak wyłączyć zabezpieczenie sprężynowe dla konkretnego adresu URL

Question

Używam bezstanową bezpieczeństwa sprężyny, ale w przypadku rejestracja Chcę wyłączyć wiosna security.I wyłączona za pomocą

antMatchers("/api/v1/signup").permitAll(). 

ale to nie działa, otrzymuję błąd poniżej:

message=An Authentication object was not found in the SecurityContext, type=org.springframework.security.authentication.AuthenticationCredentialsNotFoundException 

Myślę, że to oznacza, filtry zabezpieczające sprężyny pracują

kolejność mój adres URL zawsze będzie "/ api/v1"

Moja wiosna config jest

@Override 
    protected void configure(HttpSecurity http) throws Exception { 

     http. 
     csrf().disable(). 
     sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS). 
     and(). 
     authorizeRequests(). 
     antMatchers("/api/v1/signup").permitAll(). 
     anyRequest().authenticated(). 
     and(). 
     anonymous().disable(); 
     http.addFilterBefore(new AuthenticationFilter(authenticationManager()), BasicAuthenticationFilter.class); 
    } 

Mój filtr uwierzytelniania jest

@Override 
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
     HttpServletRequest httpRequest = asHttp(request); 
     HttpServletResponse httpResponse = asHttp(response); 

     String username = httpRequest.getHeader("X-Auth-Username"); 
     String password = httpRequest.getHeader("X-Auth-Password"); 
     String token = httpRequest.getHeader("X-Auth-Token"); 

     String resourcePath = new UrlPathHelper().getPathWithinApplication(httpRequest); 

     try { 

      if (postToAuthenticate(httpRequest, resourcePath)) {    
       processUsernamePasswordAuthentication(httpResponse, username, password); 
       return; 
      } 

      if(token != null){ 
       processTokenAuthentication(token); 
      } 
      chain.doFilter(request, response); 
     } catch (InternalAuthenticationServiceException internalAuthenticationServiceException) { 
      SecurityContextHolder.clearContext(); 
      logger.error("Internal authentication service exception", internalAuthenticationServiceException); 
      httpResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); 
     } catch (AuthenticationException authenticationException) { 
      SecurityContextHolder.clearContext(); 
      httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED, authenticationException.getMessage()); 
     } finally { 
     } 
    } 

    private HttpServletRequest asHttp(ServletRequest request) { 
      return (HttpServletRequest) request; 
     } 

     private HttpServletResponse asHttp(ServletResponse response) { 
      return (HttpServletResponse) response; 
     } 

     private boolean postToAuthenticate(HttpServletRequest httpRequest, String resourcePath) { 
      return Constant.AUTHENTICATE_URL.equalsIgnoreCase(resourcePath) && httpRequest.getMethod().equals("POST"); 
     } 

     private void processUsernamePasswordAuthentication(HttpServletResponse httpResponse,String username, String password) throws IOException { 
      Authentication resultOfAuthentication = tryToAuthenticateWithUsernameAndPassword(username, password); 
      SecurityContextHolder.getContext().setAuthentication(resultOfAuthentication); 
      httpResponse.setStatus(HttpServletResponse.SC_OK); 
      httpResponse.addHeader("Content-Type", "application/json"); 
      httpResponse.addHeader("X-Auth-Token", resultOfAuthentication.getDetails().toString()); 
     } 

     private Authentication tryToAuthenticateWithUsernameAndPassword(String username,String password) { 
      UsernamePasswordAuthenticationToken requestAuthentication = new UsernamePasswordAuthenticationToken(username, password); 
      return tryToAuthenticate(requestAuthentication); 
     } 

     private void processTokenAuthentication(String token) { 
      Authentication resultOfAuthentication = tryToAuthenticateWithToken(token); 
      SecurityContextHolder.getContext().setAuthentication(resultOfAuthentication); 
     } 

     private Authentication tryToAuthenticateWithToken(String token) { 
      PreAuthenticatedAuthenticationToken requestAuthentication = new PreAuthenticatedAuthenticationToken(token, null); 
      return tryToAuthenticate(requestAuthentication); 
     } 

     private Authentication tryToAuthenticate(Authentication requestAuthentication) { 
      Authentication responseAuthentication = authenticationManager.authenticate(requestAuthentication); 
      if (responseAuthentication == null || !responseAuthentication.isAuthenticated()) { 
       throw new InternalAuthenticationServiceException("Unable to authenticate Domain User for provided credentials"); 
      } 
      logger.debug("User successfully authenticated"); 
      return responseAuthentication; 
     } 

Moje kontroler jest

@RestController 
public class UserController { 

    @Autowired 
    UserService userService; 

    /** 
    * to pass user info to service 
    */ 
    @RequestMapping(value = "api/v1/signup",method = RequestMethod.POST) 
    public String saveUser(@RequestBody User user) { 
     userService.saveUser(user); 
     return "User registerted successfully"; 
    } 
} 

Jestem całkowicie nowy na wiosnę, proszę mi pomóc jak to zrobić?

Answer 1

Podczas korzystania permitAll to znaczy każdy uwierzytelniony użytkownik, jednak wyłączono dostęp anonimowy, tak że nie będzie działać.

Należy zignorować niektóre adresy URL, aby zastąpić metodę configure, która pobiera obiekt WebSecurity i .

@Override 
public void configure(WebSecurity web) throws Exception { 
    web.ignoring().antMatchers("/api/v1/signup"); 
} 

I usuń tę linię z części HttpSecurity. Dzięki temu Spring Security zignoruje ten URL i nie zastosuje do nich żadnych filtrów.

Answer 2

<http pattern="/resources/**" security="none"/> 

Albo z konfiguracją Java:

web.ignoring().antMatchers("/resources/**"); 

Zamiast starego:

<intercept-url pattern="/resources/**" filters="none"/> 

dla exp. wyłączyć zabezpieczenia na stronie logowania:

<intercept-url pattern="/login*" filters="none" /> 

Answer 3

Mam lepszy sposób:

http 
    .authorizeRequests() 
    .antMatchers("/api/v1/signup/**").permitAll() 
    .anyRequest().authenticated() 

Answer 4

To może nie być pełna odpowiedź na to pytanie, jednak jeśli szukasz sposobu, aby wyłączyć ochronę CSRF można zrobić:

@EnableWebSecurity 
public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 

    @Override 
    protected void configure(HttpSecurity http) throws Exception { 
     http.authorizeRequests() 
       .antMatchers("/web/admin/**").hasAnyRole(ADMIN.toString(), GUEST.toString()) 
       .anyRequest().permitAll() 
       .and() 
       .formLogin().loginPage("/web/login").permitAll() 
       .and() 
       .csrf().ignoringAntMatchers("/contact-email") 
       .and() 
       .logout().logoutUrl("/web/logout").logoutSuccessUrl("/web/").permitAll(); 
    } 

    @Autowired 
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { 
     auth.inMemoryAuthentication() 
       .withUser("admin").password("admin").roles(ADMIN.toString()) 
       .and() 
       .withUser("guest").password("guest").roles(GUEST.toString()); 
    } 

} 

Mam pełną konfigurację, ale kluczowa linia to:

.csrf().ignoringAntMatchers("/contact-email")