Spring Security Web : StrictHttpFirewall HTTP防火墙(严格模式)

最新推荐文章于 2024-08-16 14:24:43 发布
最新推荐文章于 2024-08-16 14:24:43 发布
阅读量1.1w 收藏 11
点赞数 5
分类专栏： Spring Web Spring Security 分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andy_zhang2007/article/details/90511688
版权

概述

功能介绍

StrictHttpFirewall是Spring Security Web提供的一个HTTP防火墙(对应概念模型接口HttpFirewall)实现,该实现采用了严格模式，遇到任何可疑的请求，会通过抛出异常RequestRejectedException拒绝该请求。StrictHttpFirewall也是Spring Security Web在安全过滤器代理FilterChainProxy内置缺省使用的HTTP防火墙机制。

该防火墙实现使用如下规则决定是否拒绝一个请求:

  • 不在HTTP method许可清单的请求会被拒绝。

    HTTP method许可清单通过方法setAllowedHttpMethods(Collection)设置。
    缺省被允许的HTTP method有 [DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT]。

  • 如果请求URL 不是标准化(normalize)的URL则该请求会被拒绝，以避免安全限制被绕过。

    在StrictHttpFirewall中该规则不能被禁用，因为关掉该限制风险极高。一种想通过该规则又想尽量安全的替代方法，是在请求到达前对URL进行标准化处理。跟StrictHttpFirewall相对应的另外一个HttpFirewall实现是DefaultHttpFirewall，DefaultHttpFirewall中对请求URL的限制没有这一条，但是相应地安全性就下降了。

    这里需要提醒的是，对请求URL做标准化处理是一种比较"脆弱"的(fragile)手段。建议即使请求会被拒绝，也尽量不要对其URL做标准化。

    标准化的URL必须符合以下条件 :
    在其requestURI/contextPath/servletPath/pathInfo中，必须不能包含以下字符串序列之一 :
    ["//","./","/…/","/."]

  • 如果请求URL 中包含不可打印ASCII字符则该请求会被拒绝。

    该规则不可关闭，因为对应风极高。

    有关知识点 :

    1. requestURI : URL中去除协议,主机名,端口之后其余的部分,
    2. contextPath : requestURI中对应webapp的部分,
    3. servletPath ： requestURI中对应识别Servlet的部分
    4. ,pathInfo : requestURI中去掉contextPath,servletPath剩下的部分

  • 如果请求URL（无论是URL编码前还是URL编码后)包含了分号(;或者%3b或者%3B)则该请求会被拒绝。

    通过开关函数setAllowSemicolon(boolean) 可以设置是否关闭该规则。缺省使用该规则。

  • 如果请求URL（无论是URL编码前还是URL编码后)包含了斜杠(%2f或者%2F)则该请求会被拒绝。

    通过开关函数setAllowUrlEncodedSlash(boolean) 可以设置是否关闭该规则。缺省使用该规则。

  • 如果请求URL（无论是URL编码前还是URL编码后)包含了反斜杠(\或者%5c或者%5B)则该请求会被拒绝。

    通过开关函数setAllowBackSlash(boolean) 可以设置是否关闭该规则。缺省使用该规则。

  • 如果请求URL在URL编码后包含了%25(URL编码了的百分号%),或者在URL编码前包含了百分号%则该请求会被拒绝。

    通过开关函数setAllowUrlEncodedPercent(boolean) 可以设置是否关闭该规则。缺省使用该规则。

  • 如果请求URL在URL编码后包含了URL编码的英文句号.(%2e或者%2E)则该请求会被拒绝。

    通过开关函数setAllowUrlEncodedPeriod(boolean) 可以设置是否关闭该规则。缺省使用该规则。

注意：这里提到的"URL编码后"对应英文是URL encoded,"URL编码前"指的是未执行URL编码的原始URL字符串，或者是"URL编码后"的URL经过解码URL decode得到的URL字符串(应该等于原始URL字符串)。

继承关系

StrictHttpFirewall

使用介绍


// FilterChainProxy 代码片段
private void doFilterInternal(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {

		// 这里 firewall 缺省就是一个 StrictHttpFirewall 实例，
		// FilterChainProxy 允许外部设置使用指定的 firewall 实例
		// 这里对请求/响应对象进行防火墙增强，如果请求被检测到可疑会被拒绝,
		// 响应对象会被增加输出头部/cookie/redirect location值时的安全检查
		FirewalledRequest fwRequest = firewall
				.getFirewalledRequest((HttpServletRequest) request);
		HttpServletResponse fwResponse = firewall
				.getFirewalledResponse((HttpServletResponse) response);

		// 获取跟该请求匹配的所有安全过滤器
		List<Filter> filters = getFilters(fwRequest);

		if (filters == null || filters.size() == 0) {
			if (logger.isDebugEnabled()) {
				logger.debug(UrlUtils.buildRequestUrl(fwRequest)
						+ (filters == null ? " has no matching filters"
								: " has an empty filter list"));
			}

			fwRequest.reset();

			// 调用安全过滤器链 
			chain.doFilter(fwRequest, fwResponse);

			return;
		}

		// 构造并调用安全过滤器链  
		VirtualFilterChain vfc = new VirtualFilterChain(fwRequest, chain, filters);
		vfc.doFilter(fwRequest, fwResponse);
	}

源代码

源代码版本 : Spring Security Web 5.1.4.RELEASE

package org.springframework.security.web.firewall;

import org.springframework.http.HttpMethod;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class StrictHttpFirewall implements HttpFirewall {
	/**
	 * Used to specify to #setAllowedHttpMethods(Collection) that any HTTP method should be allowed.
	 */
	private static final Set<String> ALLOW_ANY_HTTP_METHOD = Collections.unmodifiableSet(Collections.emptySet());

	private static final String ENCODED_PERCENT = "%25";

	private static final String PERCENT = "%";

	private static final List<String> FORBIDDEN_ENCODED_PERIOD = 
		Collections.unmodifiableList(Arrays.asList("%2e", "%2E"));

	private static final List<String> FORBIDDEN_SEMICOLON = 
		Collections.unmodifiableList(Arrays.asList(";", "%3b", "%3B"));

	private static final List<String> FORBIDDEN_FORWARDSLASH = 
		Collections.unmodifiableList(Arrays.asList("%2f", "%2F"));

	private static final List<String> FORBIDDEN_BACKSLASH = 
		Collections.unmodifiableList(Arrays.asList("\\", "%5c", "%5C"));

	private Set<String> encodedUrlBlacklist = new HashSet<String>();

	private Set<String> decodedUrlBlacklist = new HashSet<String>();

	private Set<String> allowedHttpMethods = createDefaultAllowedHttpMethods();

	public StrictHttpFirewall() {
		urlBlacklistsAddAll(FORBIDDEN_SEMICOLON);
		urlBlacklistsAddAll(FORBIDDEN_FORWARDSLASH);
		urlBlacklistsAddAll(FORBIDDEN_BACKSLASH);

		this.encodedUrlBlacklist.add(ENCODED_PERCENT);
		this.encodedUrlBlacklist.addAll(FORBIDDEN_ENCODED_PERIOD);
		this.decodedUrlBlacklist.add(PERCENT);
	}


	public void setUnsafeAllowAnyHttpMethod(boolean unsafeAllowAnyHttpMethod) {
		this.allowedHttpMethods = unsafeAllowAnyHttpMethod ? ALLOW_ANY_HTTP_METHOD : createDefaultAllowedHttpMethods();
	}

	public void setAllowedHttpMethods(Collection<String> allowedHttpMethods) {
		if (allowedHttpMethods == null) {
			throw new IllegalArgumentException("allowedHttpMethods cannot be null");
		}
		if (allowedHttpMethods == ALLOW_ANY_HTTP_METHOD) {
			this.allowedHttpMethods = ALLOW_ANY_HTTP_METHOD;
		} else {
			this.allowedHttpMethods = new HashSet<>(allowedHttpMethods);
		}
	}

	
	public void setAllowSemicolon(boolean allowSemicolon) {
		if (allowSemicolon) {
			urlBlacklistsRemoveAll(FORBIDDEN_SEMICOLON);
		} else {
			urlBlacklistsAddAll(FORBIDDEN_SEMICOLON);
		}
	}


	public void setAllowUrlEncodedSlash(boolean allowUrlEncodedSlash) {
		if (allowUrlEncodedSlash) {
			urlBlacklistsRemoveAll(FORBIDDEN_FORWARDSLASH);
		} else {
			urlBlacklistsAddAll(FORBIDDEN_FORWARDSLASH);
		}
	}


	public void setAllowUrlEncodedPeriod(boolean allowUrlEncodedPeriod) {
		if (allowUrlEncodedPeriod) {
			this.encodedUrlBlacklist.removeAll(FORBIDDEN_ENCODED_PERIOD);
		} else {
			this.encodedUrlBlacklist.addAll(FORBIDDEN_ENCODED_PERIOD);
		}
	}

	public void setAllowBackSlash(boolean allowBackSlash) {
		if (allowBackSlash) {
			urlBlacklistsRemoveAll(FORBIDDEN_BACKSLASH);
		} else {
			urlBlacklistsAddAll(FORBIDDEN_BACKSLASH);
		}
	}


	public void setAllowUrlEncodedPercent(boolean allowUrlEncodedPercent) {
		if (allowUrlEncodedPercent) {
			this.encodedUrlBlacklist.remove(ENCODED_PERCENT);
			this.decodedUrlBlacklist.remove(PERCENT);
		} else {
			this.encodedUrlBlacklist.add(ENCODED_PERCENT);
			this.decodedUrlBlacklist.add(PERCENT);
		}
	}

	private void urlBlacklistsAddAll(Collection<String> values) {
		this.encodedUrlBlacklist.addAll(values);
		this.decodedUrlBlacklist.addAll(values);
	}

	private void urlBlacklistsRemoveAll(Collection<String> values) {
		this.encodedUrlBlacklist.removeAll(values);
		this.decodedUrlBlacklist.removeAll(values);
	}

	@Override
	public FirewalledRequest getFirewalledRequest(HttpServletRequest request) throws RequestRejectedException {
		rejectForbiddenHttpMethod(request);
		rejectedBlacklistedUrls(request);

		if (!isNormalized(request)) {
			throw new RequestRejectedException("The request was rejected because the URL was not normalized.");
		}

		String requestUri = request.getRequestURI();
		if (!containsOnlyPrintableAsciiCharacters(requestUri)) {
			throw new RequestRejectedException(
				"The requestURI was rejected because it can only contain printable ASCII characters.");
		}
		return new FirewalledRequest(request) {
			@Override
			public void reset() {
			}
		};
	}

	private void rejectForbiddenHttpMethod(HttpServletRequest request) {
		if (this.allowedHttpMethods == ALLOW_ANY_HTTP_METHOD) {
			return;
		}
		if (!this.allowedHttpMethods.contains(request.getMethod())) {
			throw new RequestRejectedException("The request was rejected because the HTTP method \"" +
					request.getMethod() +
					"\" was not included within the whitelist " +
					this.allowedHttpMethods);
		}
	}

	private void rejectedBlacklistedUrls(HttpServletRequest request) {
		for (String forbidden : this.encodedUrlBlacklist) {
			if (encodedUrlContains(request, forbidden)) {
				throw new RequestRejectedException(
					"The request was rejected because the URL contained a potentially malicious String \"" 
					+ forbidden + "\"");
			}
		}
		for (String forbidden : this.decodedUrlBlacklist) {
			if (decodedUrlContains(request, forbidden)) {
				throw new RequestRejectedException(
					"The request was rejected because the URL contained a potentially malicious String \"" 
					+ forbidden + "\"");
			}
		}
	}

	@Override
	public HttpServletResponse getFirewalledResponse(HttpServletResponse response) {
		return new FirewalledResponse(response);
	}

	private static Set<String> createDefaultAllowedHttpMethods() {
		Set<String> result = new HashSet<>();
		result.add(HttpMethod.DELETE.name());
		result.add(HttpMethod.GET.name());
		result.add(HttpMethod.HEAD.name());
		result.add(HttpMethod.OPTIONS.name());
		result.add(HttpMethod.PATCH.name());
		result.add(HttpMethod.POST.name());
		result.add(HttpMethod.PUT.name());
		return result;
	}


    // 对请求 request URL 的四个部分做标准化检查 :
    // requestURI,  contextPath, servletPath, pathInfo
	private static boolean isNormalized(HttpServletRequest request) {
		if (!isNormalized(request.getRequestURI())) {
			return false;
		}
		if (!isNormalized(request.getContextPath())) {
			return false;
		}
		if (!isNormalized(request.getServletPath())) {
			return false;
		}
		if (!isNormalized(request.getPathInfo())) {
			return false;
		}
		return true;
	}

	private static boolean encodedUrlContains(HttpServletRequest request, String value) {
		if (valueContains(request.getContextPath(), value)) {
			return true;
		}
		return valueContains(request.getRequestURI(), value);
	}

	private static boolean decodedUrlContains(HttpServletRequest request, String value) {
		if (valueContains(request.getServletPath(), value)) {
			return true;
		}
		if (valueContains(request.getPathInfo(), value)) {
			return true;
		}
		return false;
	}

	private static boolean containsOnlyPrintableAsciiCharacters(String uri) {
		int length = uri.length();
		for (int i = 0; i < length; i++) {
			char c = uri.charAt(i);
			if (c < '\u0020' || c > '\u007e') {
				return false;
			}
		}

		return true;
	}

	private static boolean valueContains(String value, String contains) {
		return value != null && value.contains(contains);
	}


    // 检测一个路径参数path是否是一个标准化了的路径 :
    // 1. 如果路径中包含连续两个反斜杠 "//" 则会被认为是非标准化的
    // 2. 如果路径中包含 "./" , "/../" , 或者 "/." , 则会被认为是非标准化的
	private static boolean isNormalized(String path) {
		if (path == null) {
			return true;
		}

		if (path.indexOf("//") > -1) {
			return false;
		}

		for (int j = path.length(); j > 0;) {
			int i = path.lastIndexOf('/', j - 1);
			int gap = j - i;

			if (gap == 2 && path.charAt(i + 1) == '.') {
				// ".", "/./" or "/."
				return false;
			} else if (gap == 3 && path.charAt(i + 1) == '.' && path.charAt(i + 2) == '.') {
				return false;
			}

			j = i;
		}

		return true;
	}

}

参考文章

安迪源文
关注
专栏目录
详解Spring Security中的HttpBasic登录验证模式
08-25
HttpBasic登录验证模式是Spring Security实现登录验证最简单的一种方式，也可以说是最简陋的一种方式，这篇文章主要介绍了Spring Security的HttpBasic登录验证模式,需要的朋友可以参考下
Spring Boot Security自带功能齐全的HttpFirewall防火墙
allway2的博客
08-09 2042
在这篇文章中，我将解释 Spring 的 HttpFirewall 是什么，它提供的安全保护类型以及它在 Spring 的 Security 中的位置。此功能，因为它被认为具有极高的风险。在讨论 Spring Security 时，通常会非常关注 Spring 的安全过滤器（这是理所当然的），但不明显的是 HttpFirewall 是我们的第一道防线。基本上，Http 防火墙实施的规则会强制增加安全性，以净化和保护我们免受可能有害的精心制作的 URL 的侵害，甚至在它们到达安全过滤器链之前。...
报错: The request was rejected because the URL contained a potentially malicious String “//“
最新发布
比个帽的博客
08-16 1313
Spring Security 框架中提供了一个 HttpFirewall，这是一个请求防火墙，它可以自动处理掉一些非法请求，请求地址格式中不能包含;等字符或编码，必须是标准化 URL。如果希望请求地址中可以出现 %，在SpringSecurity中进行如下配置。
Spring Security 之 StrictHttpFirewall 坑
Hypora的博客
10-14 4188
这个防火墙有个坑啊 啊 啊。。。。。 事情原由：项目初次引入security为swagger相关页面做验证 异常：org.springframework.security.web.firewall.RequestRejectedException: The request was rejected because the URL was not normalized. 解决: 解决方...
Spring Security(学习笔记) --HttpFirewall防火墙！
TONGZHOUGONGDU的博客
04-29 887
我们知道，在Servlet容器规范中，为HttpServletRequest定义了一些属性，如ContextPath.ServletPath等，这些属性我们都可以通过get方法获得，但是，在不同的容器中，对这些属性的值处理方案也不同，有些容器会对属性的值进行预处理，有些则不会，这样就比较混乱了，不同容器的差异，有可能会造成不安全的隐患。因此，Spring Security就提供了HttpFirewall来统一进行管理。//对请求对象进行检验并封装//对返回对象进行封装主要有两个实现类。
HttpFireWall
凌晨12点，说出你的知心话
01-06 521
public interface HttpFirewall { FirewalledRequest getFirewalledRequest(HttpServletRequest request) throws RequestRejectedException; HttpServletResponse getFirewalledResponse(HttpServletResponse r...
Spring Security Web : DefaultHttpFirewall HTTP防火墙(缺省模式)
Details Inside Spring
05-24 3133
概述 功能介绍 DefaultHttpFirewall是Spring Security Web提供的一个HTTP防火墙(对应概念模型接口HttpFirewall)实现。该实现是所谓的缺省实现，但实际上Spring Security Web缺省使用的并不是DefaultHttpFirewall,而是严格模式的StrictHttpFirewall。其原因主要是StrictHttpFirewall对安全...
org.springframework.security.web.firewall.RequestRejectedException: The request was rejected because
Nostalgia____的博客
03-15 6711
org.springframework.security.web.firewall.RequestRejectedException
8.Spring security中的HttpFirewall
EdSheeran的博客
03-11 2068
文章目录*`HttpFirewall`**8.1`HttpFirewall`简介**8.2`HttpFirewall`严格模式**8.2.1`rejectForbiddenHttpMethod`**8.2.2`rejectedBlocklistedUrls`**8.2.3`rejectedUntrustedHosts`**8.2.4`isNormalized`**8.2.5`containsOnlyPrintableAsciiCharacters`**8.3`HttpFirewall`普通模式* HttpF
SpringBoot中SpringSecurity 报错：org.springframework.security.web.firewall.RequestRejectedException
一个简单的描述，我想你不会感兴趣的
08-04 4120
根据报错org.springframework.security.web.firewall.RequestRejectedException中的信息分析错误
Spring Security 6.x 系列【47】配置篇之HttpSecurity、WebSecurity
记录知识、锤炼自我
05-30 1753
在之前的文档中，关于配置，我们都是基于HttpSecurity构建SecurityFilterChain，也了解了很多Spring Security的相关配置，接下来继续介绍一些其他用法。
SpringSecurity如何实现配置单个HttpSecurity
08-18
主要介绍了SpringSecurity如何实现配置单个HttpSecurity,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring security原理和机制 | Spring Boot 35
热门推荐
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
Spring Security 6.x 系列（1）—— 初识Spring Security
gmHappy
10-05 2万+
`Spring Security`作为一个功能完善的安全框架，具有以下特性： - **认证（Authentication）**：解决 "你是谁" 的问题，验证系统中是否有这个“用户”(用户/设备/系统)，也就是我们常说的“登录”。 - **授权（Authorization）**：权限控制/鉴别，解决的是系统中某个用户能够访问哪些资源，即“你能干什么”的问题。`Spring Security` 支持基于 `URL` 的请求授权、方法访问授权、对象访问授权。
解决Maven导入依赖时出现Cannot resolve org.springframework:spring-webmvc:5.3.1
m0_59376721的博客
03-18 3万+
当我们在导入有关SpringMVC相关依赖时，出现 Cannot resolve org.springframework:spring-webmvc:5.3.1 原因一：网络不好导致文件未下载 原因二：spring-webmvc为小写，如果不小心将spring写成了Spring，后来再改回spring，是无法导入的。 解决原因二方法： 在IDEA中点击file，然后点击Setting 找到依赖下载的地方，我的依赖下载在，每个人情况不一样。当时配置Maven的时候，根据自己所下载的位置 然后根据这个位
Spring Security漏洞防护—HttpFirewall和 HTTPS
深圳市多克创新科技有限公司
10-26 996
Spring Security漏洞防护—HttpFirewall和 HTTPS
Linux网络—firewalld防火墙基础（实验+理论）
qq_48191100的博客
11-04 919
目录前言一、Firewalld，iptables概述1.1 Firewalld 简介1.2 iptables 简介1.3 Firewalld和iptables的关系1.3.1 netfilter1.3.2 Firewalld、iptables1.3.3 netfilter和Firewalld，iptables关系1.3.4 Firewalld和iptables的区别1.3.5 CentOS 6 和CentOS 7 防火墙的区别二、Firewalld2.1 Firewalld网络区域介绍2.2 Firewal
Spring Security 自带防火墙！你都不知道自己的系统有多安全！
m0_62261166的博客
04-15 746
使用 URL 地址编码之后，是 %2F%2F，其中 F 大小写无所谓，所以请求地址中也能不出现 “%2f%2f”, “%2f%2F”, “%2F%2f”, “%2F%2F”。@MatrixVariable 是 Spring3.2 中带来的功能，这种方式拓展了请求参数的传递格式，使得参数之间可以用。设置完成之后，再去访问相同的接口，可以看到，此时虽然还是报错，但是错误是 404 了，而不是一开始那个不允许。首先，对于请求的方法，只允许白名单中的方法，也就是说，不是所有的 HTTP 请求方法都可以执行。
The request was rejected because the URL contained a potentially malicious String “//“
好幸运
04-20 1566
解决方案 把多余的/去掉就好了。 但我疑惑的是为什么php就可以，java报错了，后来查到是Spring Security拦截了。 源代码在StrictHttpFirewall#setAllowUrlEncodedDoubleSlash。 这个类里面其他的方法应该也和特殊字符有关（如setAllowBackSlash、setAllowUrlEncodedPercent等）。 重新注入StrictHttpFirewall对象，就可以让它支持//的模式。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值