多重身份验证的 Spring OAuth2 实现的完整代码已上传至 a file sharing site at this link .下面给出的说明可以在几分钟内在任何计算机上重现当前问题。

当前问题:



大多数身份验证算法都能正常工作。直到下面显示的控制流的最后，程序才会中断。具体来说，一个 Invalid CSRF token found for http://localhost:9999/uaa/oauth/token在 的末尾抛出错误第二遍 以下。上面链接中的应用程序是通过添加自定义 OAuth2RequestFactory 开发的, TwoFactorAuthenticationFilter和 TwoFactorAuthenticationController到 authserver app本 Spring Boot OAuth2 GitHub sample . 需要对以下代码进行哪些具体更改才能解决此 CSRF token 错误并启用 2 因素身份验证？

我的研究使我怀疑 CustomOAuth2RequestFactory ( API at this link ) 可能是配置解决方案的地方，因为它定义了管理 AuthorizationRequest 的方式。 s 和 TokenRequest s。

This section of the official OAuth2 spec表示 state向授权端点发出的请求的参数是 csrf 所在的位置添加 token 。

此外，链接中的代码使用 the Authorization Code Grant Type described at this link to the official spec ，这意味着流程中的步骤 C 不会更新 csrf代码，从而触发步骤 D 中的错误。(您可以在 the official spec 中查看包括步骤 C 和步骤 D 的整个流程。)

当前错误周围的控制流:



当前错误是在 期间抛出的第二遍 通过 TwoFactorAuthenticationFilter在下面的流程图中。一切都按预期工作，直到控制流进入 第二遍 .

以下流程图说明了可下载应用程序中的代码采用的两因素身份验证过程的控制流程。



具体来说，Firefox HTTP POST 序列的 header s 和 GET s 显示相同 XSRF cookie 随序列中的每个请求一起发送。 XSRF token 值在 POST /secure/two_factor_authentication 之后才引起问题，在 /oauth/authorize 触发服务器处理和 /oauth/token端点，带有 /oauth/token扔Invalid CSRF token found for http://localhost:9999/uaa/oauth/token错误。

了解上述控制流程图与/oauth/authorize的关系和 /oauth/token端点，您可以并排比较上面的流程图 with the chart for the single factor flow at the official spec在单独的浏览器窗口中。 第二遍 以上只是第二次执行单因素官方规范中的步骤，但在 期间具有更大的权限第二遍 .

日志内容:



HTTP 请求和响应 header 表明:

1.) 给 9999/login 的帖子使用正确的 username和 password提交结果重定向到 9999/authorize?client_id=acme&redirect_uri=/login&response_type=code&state=sGXQ4v后跟一个 GET 9999/secure/two_factor_authenticated .一个 XSRF 代币在这些交易所中保持不变。

2.) 给 9999/secure/two_factor_authentication 的帖子使用正确的密码发送相同的 XSRF token ，并成功重定向到 POST 9999/oauth/authorize并将其变成 TwoFactorAuthenticationFilter.doFilterInternal()然后转到 request 9999/oauth/token ，但是 9999/oauth/token拒绝请求，因为相同的旧 XSRF token 与新的 XSRF 不匹配 token 值，显然是在 期间创建的第一次通过 .
1.)之间的一个明显区别和 2.)是第二个request 9999/oauth/authorize在 2.)不包含第一个请求中包含的 url 参数 9999/authorize?client_id=acme&redirect_uri=/login&response_type=code&state=sGXQ4v在 1.) ，也在 the official spec 中定义.但目前尚不清楚这是否是导致问题的原因。

此外，不清楚如何访问参数以发送来自 TwoFactorAuthenticationController.POST 的完整请求。 .我做了 parameters 的 SYSO Map在 HttpServletRequest为 POST 9999/secure/two_factor_authentication Controller 方法，它包含的只是 pinVal和 _csrf变量。

您可以在文件共享站点 by clicking on this link 上阅读所有 HTTP header 和 Spring Boot 日志。 .

失败的方法:



我试过 @RobWinch's approach to a similar problem in the Spring Security 3.2 environment ，但该方法似乎不适用于 Spring OAuth2 的上下文。具体来说，当以下XSRF更新代码块在 TwoFactorAuthenticationFilter 中被取消注释下面显示的代码，下游请求 header 确实显示了一个不同的/新的 XSRF token 值，但抛出相同的错误。

if(AuthenticationUtil.hasAuthority(ROLE_TWO_FACTOR_AUTHENTICATED)){
    CsrfToken token = (CsrfToken) request.getAttribute("_csrf");
    response.setHeader("XSRF-TOKEN"/*"X-CSRF-TOKEN"*/, token.getToken());
}

public class CustomOAuth2RequestFactory extends DefaultOAuth2RequestFactory {

    public static final String SAVED_AUTHORIZATION_REQUEST_SESSION_ATTRIBUTE_NAME = "savedAuthorizationRequest";

    public CustomOAuth2RequestFactory(ClientDetailsService clientDetailsService) {
        super(clientDetailsService);
    }

    @Override
    public AuthorizationRequest createAuthorizationRequest(Map<String, String> authorizationParameters) {
        ServletRequestAttributes attr = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
        HttpSession session = attr.getRequest().getSession(false);
        if (session != null) {
            AuthorizationRequest authorizationRequest = (AuthorizationRequest) session.getAttribute(SAVED_AUTHORIZATION_REQUEST_SESSION_ATTRIBUTE_NAME);
            if (authorizationRequest != null) {
                session.removeAttribute(SAVED_AUTHORIZATION_REQUEST_SESSION_ATTRIBUTE_NAME);
                return authorizationRequest;
            }
        }

        return super.createAuthorizationRequest(authorizationParameters);
    }
}

//This class is added per: https://stackoverflow.com/questions/30319666/two-factor-authentication-with-spring-security-oauth2
/**
 * Stores the oauth authorizationRequest in the session so that it can
 * later be picked by the {@link com.example.CustomOAuth2RequestFactory}
 * to continue with the authoriztion flow.
 */
public class TwoFactorAuthenticationFilter extends OncePerRequestFilter {

    private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
    private OAuth2RequestFactory oAuth2RequestFactory;
    //These next two are added as a test to avoid the compilation errors that happened when they were not defined.
    public static final String ROLE_TWO_FACTOR_AUTHENTICATED = "ROLE_TWO_FACTOR_AUTHENTICATED";
    public static final String ROLE_TWO_FACTOR_AUTHENTICATION_ENABLED = "ROLE_TWO_FACTOR_AUTHENTICATION_ENABLED";

    @Autowired
    public void setClientDetailsService(ClientDetailsService clientDetailsService) {
        oAuth2RequestFactory = new DefaultOAuth2RequestFactory(clientDetailsService);
    }

    private boolean twoFactorAuthenticationEnabled(Collection<? extends GrantedAuthority> authorities) {
        System.out.println(">>>>>>>>>>> List of authorities includes: ");
        for (GrantedAuthority authority : authorities) {
            System.out.println("auth: "+authority.getAuthority() );
        }
        return authorities.stream().anyMatch(
            authority -> ROLE_TWO_FACTOR_AUTHENTICATION_ENABLED.equals(authority.getAuthority())
        );
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        System.out.println("------------------ INSIDE TwoFactorAuthenticationFilter.doFilterInternal() ------------------------");
        // Check if the user hasn't done the two factor authentication.
        if (AuthenticationUtil.isAuthenticated() && !AuthenticationUtil.hasAuthority(ROLE_TWO_FACTOR_AUTHENTICATED)) {
        System.out.println("++++++++++++++++++++++++ AUTHENTICATED BUT NOT TWO FACTOR +++++++++++++++++++++++++");
        AuthorizationRequest authorizationRequest = oAuth2RequestFactory.createAuthorizationRequest(paramsFromRequest(request));
            /* Check if the client's authorities (authorizationRequest.getAuthorities()) or the user's ones
               require two factor authenticatoin. */
        System.out.println("======================== twoFactorAuthenticationEnabled(authorizationRequest.getAuthorities()) is: " + twoFactorAuthenticationEnabled(authorizationRequest.getAuthorities()) );
        System.out.println("======================== twoFactorAuthenticationEnabled(SecurityContextHolder.getContext().getAuthentication().getAuthorities()) is: " + twoFactorAuthenticationEnabled(SecurityContextHolder.getContext().getAuthentication().getAuthorities()) );
        if (twoFactorAuthenticationEnabled(authorizationRequest.getAuthorities()) ||
                twoFactorAuthenticationEnabled(SecurityContextHolder.getContext().getAuthentication().getAuthorities())) {
                // Save the authorizationRequest in the session. This allows the CustomOAuth2RequestFactory
                // to return this saved request to the AuthenticationEndpoint after the user successfully
                // did the two factor authentication.
                request.getSession().setAttribute(CustomOAuth2RequestFactory.SAVED_AUTHORIZATION_REQUEST_SESSION_ATTRIBUTE_NAME, authorizationRequest);

                // redirect the the page where the user needs to enter the two factor authentiation code
                redirectStrategy.sendRedirect(request, response,
                    ServletUriComponentsBuilder.fromCurrentContextPath()
                        .path(TwoFactorAuthenticationController.PATH)
                        .toUriString());
                return;
            }
        }
        //THE NEXT "IF" BLOCK DOES NOT RESOLVE THE ERROR WHEN UNCOMMENTED
        //if(AuthenticationUtil.hasAuthority(ROLE_TWO_FACTOR_AUTHENTICATED)){
        //    CsrfToken token = (CsrfToken) request.getAttribute("_csrf");
            // this is the value of the token to be included as either a header or an HTTP parameter
        //    response.setHeader("XSRF-TOKEN", token.getToken());
        //}

        filterChain.doFilter(request, response);
    }

    private Map<String, String> paramsFromRequest(HttpServletRequest request) {
        Map<String, String> params = new HashMap<>();
        for (Entry<String, String[]> entry : request.getParameterMap().entrySet()) {
            params.put(entry.getKey(), entry.getValue()[0]);
        }
        return params;
    }
}

最佳答案

一个想法突然出现在我的脑海中:

如果激活 session 固定，则在用户成功通过身份验证后会创建一个新 session (请参阅 SessionFixationProtectionStrategy)。如果您使用默认的 HttpSessionCsrfTokenRepository，这当然也会创建一个新的 csrf token 。由于您提到了 XSRF-TOKEN header ，因此我假设您使用了一些 JavaScript 前端。我可以想象用于登录的原始 csrf token 会被存储并在之后重新使用 - 这将不起作用，因为此 csrf token 不再有效。

您可以尝试禁用 session 固定( http.sessionManagement().sessionFixation().none() 或 <session-management session-fixation-protection="none"/> )或在登录后重新获取当前的 CSRF token 。

关于spring -/oauth/token 中的 XSRF token 无效，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37061697/