探究 Spring Security 缓存请求

发表于 | 分类于 |

为什么要缓存?

为了更好的描述问题，我们拿使用表单认证的网站举例，简化后的认证过程分为7步:

  1. 用户访问网站，打开了一个链接(origin url)。

  2. 请求发送给服务器，服务器判断用户请求了受保护的资源。

  3. 由于用户没有登录，服务器重定向到登录页面

  4. 填写表单，点击登录

  5. 浏览器将用户名密码以表单形式发送给服务器

  6. 服务器验证用户名密码。成功，进入到下一步。否则要求用户重新认证（第三步）

  7. 服务器对用户拥有的权限（角色）判定: 有权限，重定向到 origin url; 权限不足，返回状态码 403(“forbidden”).

从第3步，我们可以知道，用户的请求被中断了。

用户登录成功后（第7步），会被重定向到 origin url，spring security 通过使用缓存的 request，使得被中断的请求能够继续执行。

使用缓存

用户登录成功后，页面重定向到 origin url。浏览器发出的请求优先被拦截器 RequestCacheAwareFilter 拦截，RequestCacheAwareFilter 通过其持有的 RequestCache 对象实现 request 的恢复。

1
2
3
4
5
6
7
8
9
public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {

	// request匹配，则取出，该操作同时会将缓存的request从session中删除
	HttpServletRequest wrappedSavedRequest = requestCache.getMatchingRequest((HttpServletRequest) request, (HttpServletResponse) response);

	// 优先使用缓存的request
	chain.doFilter(wrappedSavedRequest == null ? request : wrappedSavedRequest, response);
}

何时缓存

首先，我们需要了解下 RequestCache 以及 ExceptionTranslationFilter。

RequestCache

RequestCache 接口声明了缓存与恢复操作。默认实现类是 HttpSessionRequestCache。HttpSessionRequestCache 的实现比较简单，这里只列出接口的声明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface RequestCache {

	// 将request缓存到session中
	void saveRequest(HttpServletRequest request, HttpServletResponse response);

	// 从session中取request
	SavedRequest getRequest(HttpServletRequest request, HttpServletResponse response);

	// 获得与当前request匹配的缓存，并将匹配的request从session中删除
	HttpServletRequest getMatchingRequest(HttpServletRequest request,
			HttpServletResponse response);

	// 删除缓存的request
	void removeRequest(HttpServletRequest request, HttpServletResponse response);
}

ExceptionTranslationFilter

ExceptionTranslationFilter 是 Spring Security 的核心 filter 之一，用来处理 AuthenticationException 和 AccessDeniedException 两种异常。

在我们的例子中，AuthenticationException 指的是未登录状态下访问受保护资源，AccessDeniedException 指的是登陆了但是由于权限不足(比如普通用户访问管理员界面）。

ExceptionTranslationFilter 持有两个处理类，分别是 AuthenticationEntryPoint 和 AccessDeniedHandler。

ExceptionTranslationFilter 对异常的处理是通过这两个处理类实现的，处理规则很简单：

规则1: 如果异常是 AuthenticationException，使用 AuthenticationEntryPoint 处理
规则2: 如果异常是 AccessDeniedException 且用户是匿名用户，使用 AuthenticationEntryPoint 处理
规则3: 如果异常是 AccessDeniedException 且用户不是匿名用户，如果否则交给 AccessDeniedHandler 处理

对应以下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void handleSpringSecurityException(HttpServletRequest request,
			HttpServletResponse response, FilterChain chain, RuntimeException exception)
			throws IOException, ServletException {
	if (exception instanceof AuthenticationException) {
		logger.debug(
			"Authentication exception occurred; redirecting to authentication entry point", exception);

			sendStartAuthentication(request, response, chain, (AuthenticationException) exception);
		}
	else if (exception instanceof AccessDeniedException) {
		if (authenticationTrustResolver.isAnonymous(SecurityContextHolder.getContext().getAuthentication())) {
			logger.debug("Access is denied (user is anonymous); redirecting to authentication entry point",	exception);

			sendStartAuthentication(request, response, chain, new InsufficientAuthenticationException("Full authentication is required to access this resource"));
		}
		else {
			logger.debug(
				"Access is denied (user is not anonymous); delegating to AccessDeniedHandler", exception);

			accessDeniedHandler.handle(request, response, (AccessDeniedException) exception);
		}
	}
}

AccessDeniedHandler 默认实现是 AccessDeniedHandlerImpl。该类对异常的处理是返回403错误码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void handle(HttpServletRequest request, HttpServletResponse response,
			AccessDeniedException accessDeniedException) throws IOException,
			ServletException {
	if (!response.isCommitted()) {
		if (errorPage != null) {  // 定义了errorPage
			// errorPage中可以操作该异常
			request.setAttribute(WebAttributes.ACCESS_DENIED_403,
					accessDeniedException);

			// 设置403状态码
			response.setStatus(HttpServletResponse.SC_FORBIDDEN);

			// 转发到errorPage
			RequestDispatcher dispatcher = request.getRequestDispatcher(errorPage);
			dispatcher.forward(request, response);
		}
		else { // 没有定义errorPage，则返回403状态码(Forbidden)，以及错误信息
			response.sendError(HttpServletResponse.SC_FORBIDDEN,
					accessDeniedException.getMessage());
		}
	}
}

AuthenticationEntryPoint 默认实现是 LoginUrlAuthenticationEntryPoint, 该类的处理是转发或重定向到登录页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public void commence(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException authException) throws IOException, ServletException {

	String redirectUrl = null;

	if (useForward) {

		if (forceHttps && "http".equals(request.getScheme())) {
			// First redirect the current request to HTTPS.
			// When that request is received, the forward to the login page will be
			// used.
			redirectUrl = buildHttpsRedirectUrlForRequest(request);
		}

		if (redirectUrl == null) {
			String loginForm = determineUrlToUseForThisRequest(request, response,
					authException);

			if (logger.isDebugEnabled()) {
				logger.debug("Server side forward to: " + loginForm);
			}

			RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm);

			// 转发
			dispatcher.forward(request, response);

			return;
		}
	}
	else {
		// redirect to login page. Use https if forceHttps true
		redirectUrl = buildRedirectUrlToLoginPage(request, response, authException);
	}

	// 重定向
	redirectStrategy.sendRedirect(request, response, redirectUrl);
}

了解完这些，回到我们的例子。

第3步时，用户未登录的情况下访问受保护资源，ExceptionTranslationFilter 会捕获到 AuthenticationException 异常(规则1)。页面需要跳转，ExceptionTranslationFilter 在跳转前使用 requestCache 缓存 request。

1
2
3
4
5
6
7
8
9
10
11
protected void sendStartAuthentication(HttpServletRequest request,
			HttpServletResponse response, FilterChain chain,
			AuthenticationException reason) throws ServletException, IOException {
	// SEC-112: Clear the SecurityContextHolder's Authentication, as the
	// existing Authentication is no longer considered valid
	SecurityContextHolder.getContext().setAuthentication(null);
	// 缓存 request
	requestCache.saveRequest(request, response);
	logger.debug("Calling Authentication entry point.");
	authenticationEntryPoint.commence(request, response, reason);
}

一些坑

在开发过程中，如果不理解 Spring Security 如何缓存 request，可能会踩一些坑。

举个简单例子，如果网站认证是信息存放在 header 中。第一次请求受保护资源时，请求头中不包含认证信息 ，验证失败，该请求会被缓存，之后即使用户填写了信息，也会因为request被恢复导致信息丢失从而认证失败(问题描述可以参见这里。

最简单的方案当然是不缓存request。

spring security 提供了 NullRequestCache， 该类实现了 RequestCache 接口，但是没有任何操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class NullRequestCache implements RequestCache {

	public SavedRequest getRequest(HttpServletRequest request,
			HttpServletResponse response) {
		return null;
	}

	public void removeRequest(HttpServletRequest request, HttpServletResponse response) {

	}

	public void saveRequest(HttpServletRequest request, HttpServletResponse response) {
	}

	public HttpServletRequest getMatchingRequest(HttpServletRequest request,
			HttpServletResponse response) {
		return null;
	}
}

配置 requestCache，使用如下代码即可:

1
http.requestCache().requestCache(new NullRequestCache());

补充

默认情况下，三种 request 不会被缓存。

  1. 请求地址以 /favicon.ico 结尾
  2. header中的 content-type 值为 application/json
  3. header中的 X-Requested-With 值为 XMLHttpRequest

可以参见：RequestCacheConfigurer 类中的私有方法 createDefaultSavedRequestMatcher。

附上实例代码: https://coding.net/u/tanhe123/p/SpringSecurityRequestCache

0%