Spring Security 的自定义登录是如何工作的

Question

我正在尝试通过 Spring Security。 我必须实现一个自定义登录表单，所以我需要很好地理解我的配置意味着什么。

spring-security.xml

<beans:beans xmlns="http://www.springframework.org/schema/security"
    xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security-4.0.xsd">

    <http auto-config="true">
        <intercept-url pattern="/user**" access="isAuthenticated()" />
        <form-login authentication-failure-url="/login" login-page="/login"
            login-processing-url="/login" default-target-url="/user" />
        <logout invalidate-session="true" logout-success-url="/index"
            logout-url="/logout" />
    </http>

    <authentication-manager id="custom-auth">
        <authentication-provider>
            <user-service>
                <user name="my_username" password="my_password"
                    authorities="ROLE_USER" />
            </user-service>
        </authentication-provider>
    </authentication-manager>

登录控制器

@Controller
public class LoginController {
    [....]

    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public ModelAndView doLogin() {
        System.out.println("***LOGIN_POST***");
        return new ModelAndView("users/home");
    }

    @RequestMapping(value = "/logout", method = RequestMethod.POST)
    public ModelAndView doLogout() {
        System.out.println("***LOGOUT_POST***");
        return new ModelAndView("index");
    }
}

我知道我可以使用 RequestMethod.GET 映射 /login URL，但是当我尝试在表单提交后拦截 POST 时它不起作用。

1. 我相信，但需要确认，这是因为 Security 在幕后做了一些事情：从发布的表单中获取用户名和密码值，并将它们与身份验证提供程序中的值进行比较：如果这些匹配，则显示 default-target-url , 否则用户必须重复登录。 对吗？
2. 然后我的问题是：我需要在安全登录表单中输入用户名和密码值，因为我必须向外部服务器发送 HTTP 请求以验证它们是否匹配。 在介绍安全性之前，我使用 /login GET 和 /login POST 开发了这种机制，并带有 @ModelAttribute 注释。 我现在该怎么办？
3. 使用实现 UserDetailsS​​ervice 的类更改身份验证提供程序，会发生什么？ 我相信，在这种情况下，登录表单中键入的用户名和密码会与从数据库中检索到的用户名和密码进行比较，因为它们被分配给了 User 对象。 对吗？

用户详细信息服务实现

    @Service
    public class UserDetailsServiceImpl implements UserDetailsService {
        @Autowired
        private CustomerDao customerDao;

        @Override
        public UserDetails loadUserByUsername(String username)
                throws UsernameNotFoundException {
            Customer customer = customerDao.findCustomerByUsername(username);
            return new User(customer.getUsername(), customer.getPassword(), true, true, true, true,
                Arrays.asList(new SimpleGrantedAuthority(customer.getRole())));
        }
    }

NB User 的数据一开始不在我的数据库中，那是因为我不确定 UserDetailsS​​ervice 解决方案（其中 UserDetails 仅由用户名加载）。 要检索我的 Customer 对象，我需要用户名和密码（发送到特定的外部 URL）然后，如果 JSON 响应是肯定的（用户名和密码正确），我必须发送另外 2 个 HTTP 请求以获取 Customer 的数据作为名字、姓氏、国籍等，此时我的用户可以认为已登录。

有什么建议吗？ 提前致谢。

Answer 1

1. 我相信，但需要确认，这是因为 Security 在幕后做了一些事情：从发布的表单中获取用户名和密码值，并将它们与身份验证提供程序中的值进行比较：如果这些匹配，则显示 default-target-url , 否则用户必须重复登录。 对吗？

没错。 当您在安全配置中声明<login-form>元素时，您正在配置UsernamePasswordAuthenticationFilter 。

在那里你配置一些网址：

• login-page="/login" ：指向返回登录表单的@RequestMapping的 url
• login-processing-url="/login"：触发 UsernamePasswordAuthenticationFilter 的 url。 这在spring-security中相当于构建一个后处理控制器方法。
• default-target-url="/user"：提供有效用户凭据后用户将被重定向到的默认页面。
• authentication-failure-url="/login" ：如果尝试使用无效凭据登录，用户将被重定向到的 URL。

虽然 login-processing-url、default-target-url 和 authentication-failure-url 必须是有效的 RequestMappings，但 login-processing-url 不会到达 Spring MVC 控制器层，因为它在命中 Spring MVC 调度程序 servlet 之前执行。

所以

@RequestMapping(value = "/login", method = RequestMethod.POST)
    public ModelAndView doLogin() {
        System.out.println("***LOGIN_POST***");
        return new ModelAndView("users/home");
    }

永远不会到达。

当对/login uri 进行 POST 时， UsernamePasswordAuthenticationFilter 将执行它的doFilter()方法来捕获用户提供的凭据，构建一个UsernamePasswordAuthenticationToken并将其委托给AuthenticationManager ，此Authentication将在匹配的AuthenticationProvider 中执行。

2. 然后我的问题是：我需要在安全登录表单中输入用户名和密码值，因为我必须向外部服务器发送 HTTP 请求以验证它们是否匹配。 在介绍安全性之前，我使用 /login GET 和 /login POST 开发了这种机制，并带有 @ModelAttribute 注释。 我现在该怎么办？ 我想当您过去对外部服务器执行身份验证时，您是通过将 POST /login RequestMapping 委托给一个类来完成的。

因此，只需创建一个自定义 AuthenticationProvider ，它将用户验证内容委托给您的旧逻辑：

public class ThirdPartyAuthenticationProvider implements AuthenticationProvider {
    
    private Class<? extends Authentication> supportingClass = UsernamePasswordAuthenticationToken.class;
    
    // This represents your existing username/password validation class
    // Bind it with an @Autowired or set it in your security config
    private ExternalAuthenticationValidator externalAuthenticationValidator;

    /* (non-Javadoc)
     * @see org.springframework.security.authentication.AuthenticationProvider#authenticate(org.springframework.security.core.Authentication)
     */
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        boolean validated = this.externalAuthenticationValidator.validate(authentication.getName(), authentication.getCredentials().toString());
        if(!validated){
            throw new BadCredentialsException("username and/or password not valid");
        }
        Collection<? extends GrantedAuthority> authorities = null; 
        // you must fill this authorities collection
        return new UsernamePasswordAuthenticationToken(
                    authentication.getName(),
                    authentication.getCredentials(),
                    authorities
                );      
    }

    /* (non-Javadoc)
     * @see org.springframework.security.authentication.AuthenticationProvider#supports(java.lang.Class)
     */
    @Override
    public boolean supports(Class<?> authentication) {
        return this.supportingClass.isAssignableFrom(authentication);
    }

    public ExternalAuthenticationValidator getExternalAuthenticationValidator() {
        return externalAuthenticationValidator;
    }

    public void setExternalAuthenticationValidator(ExternalAuthenticationValidator externalAuthenticationValidator) {
        this.externalAuthenticationValidator = externalAuthenticationValidator;
    }   

}

和安全配置xml：

    <beans:bean id="thirdPartyAuthenticationProvider" class="com.xxx.yyy.ThirdPartyAuthenticationProvider">
        <!-- here set your external authentication validator in case you can't autowire it -->
        <beans:property name="externalAuthenticationValidator" ref="yourExternalAuthenticationValidator" />
    </beans:bean>
    
    <security:authentication-manager id="custom-auth">
        <security:authentication-provider ref="thirdPartyAuthenticationProvider" />
    </security:authentication-manager>
    
    <security:http auto-config="true" authentication-manager-ref="custom-auth">
        <security:intercept-url pattern="/user**" access="isAuthenticated()" />
        <security:form-login authentication-failure-url="/login" login-page="/login"
            login-processing-url="/login" default-target-url="/user" />
        <security:logout invalidate-session="true" logout-success-url="/index"
            logout-url="/logout" />
        <!-- in spring security 4.x CSRF filter is enabled by default. Disable it if 
             you don't plan to use it, or at least in the first attempts -->
        <security:csrf disabled="true"/>
    </security:http>

3. 使用实现 UserDetailsS​​ervice 的类更改身份验证提供程序，会发生什么？ 我相信，在这种情况下，登录表单中键入的用户名和密码会与从数据库中检索到的用户名和密码进行比较，因为它们被分配给了 User 对象。 对吗？

正如您所说，您必须同时发送用户名和密码，我认为 UserServiceDetails 架构不符合您的要求。 我认为你应该按照我在第 2 点中的建议去做。

编辑：

最后一件事：现在我以身份验证方法发送 HTTP 请求，如果凭据正确，我会在响应中收到一个令牌，我需要访问其他外部服务器服务。 如何在我的 Spring 控制器中传递它？

要接收和处理收到的令牌，我会这样做：

ExternalAuthenticationValidator 接口：

public interface ExternalAuthenticationValidator {

    public abstract ThirdPartyValidationResponse validate(String name, String password);

}

ThirdPartyValidationResponse 模型接口：

public interface ThirdPartyValidationResponse{
    
    public boolean isValid();
    
    public Serializable getToken();

}

然后，更改 Provider 处理和管理它的方式：

public class ThirdPartyAuthenticationProvider implements AuthenticationProvider {
    
    private Class<? extends Authentication> supportingClass = UsernamePasswordAuthenticationToken.class;
    
    private ExternalAuthenticationValidator externalAuthenticationValidator;

    /* (non-Javadoc)
     * @see org.springframework.security.authentication.AuthenticationProvider#authenticate(org.springframework.security.core.Authentication)
     */
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        ThirdPartyValidationResponse response = this.externalAuthenticationValidator.validate(authentication.getName(), authentication.getCredentials().toString());
        if(!response.isValid()){
            throw new BadCredentialsException("username and/or password not valid");
        }
        Collection<? extends GrantedAuthority> authorities = null; 
        // you must fill this authorities collection
        UsernamePasswordAuthenticationToken authenticated =  
                new UsernamePasswordAuthenticationToken(
                    authentication.getName(),
                    authentication.getCredentials(),
                    authorities
                );
        authenticated.setDetails(response);
        return authenticated;
    }

    /* (non-Javadoc)
     * @see org.springframework.security.authentication.AuthenticationProvider#supports(java.lang.Class)
     */
    @Override
    public boolean supports(Class<?> authentication) {
        return this.supportingClass.isAssignableFrom(authentication);
    }

    public ExternalAuthenticationValidator getExternalAuthenticationValidator() {
        return externalAuthenticationValidator;
    }

    public void setExternalAuthenticationValidator(ExternalAuthenticationValidator externalAuthenticationValidator) {
        this.externalAuthenticationValidator = externalAuthenticationValidator;
    }   

}

现在，您必须使用此代码片段从 userDetails 中检索令牌：

        SecurityContext context = SecurityContextHolder.getContext();
        Authentication auth = context.getAuthentication();
        if(auth == null){
            throw new IllegalAccessException("Authentication is null in SecurityContext");
        }
        if(auth instanceof UsernamePasswordAuthenticationToken){
            Object details = auth.getDetails();
            if(details != null && details instanceof ThirdPartyValidationResponse){
                return ((ThirdPartyValidationResponse)details).getToken();
            }
        }
        return null;

与其将它包含在您需要的任何地方，不如创建一个从身份验证的详细信息中检索它的类：

public class SecurityContextThirdPartyTokenRetriever {
    
    public Serializable getThirdPartyToken() throws IllegalAccessException{
        SecurityContext context = SecurityContextHolder.getContext();
        Authentication auth = context.getAuthentication();
        if(auth == null){
            throw new IllegalAccessException("Authentication is null in SecurityContext");
        }
        if(auth instanceof UsernamePasswordAuthenticationToken){
            Object details = auth.getDetails();
            if(details != null && details instanceof ThirdPartyValidationResponse){
                return ((ThirdPartyValidationResponse)details).getToken();
            }
        }
        return null;
    }

}

如果您选择了最后一种方式，只需在安全 xml 配置中声明它（或使用@Service等注释进行注释）：

<beans:bean id="tokenRetriever" class="com.xxx.yyy.SecurityContextThirdPartyTokenRetriever" />

还有其他方法，例如扩展 UsernamePasswordAuthenticationToken 以包含令牌作为其上的字段，但这是我认为最简单的方法。