符号 | 符号 [] 符号 + 三者联合使用可能受到 ReDOS 攻击：
表达式：  (\d+|[1A])+z
需求: 会匹配任意数字或任意（1或A）字符串加上字符z
匹配字符串: 111111111 (10 chars)
计算步骤数: 46342

如果两个重复运算符过近，那么有可能收到攻击。请看以下例子：
例子1：
表达式：  .*\d+\.jpg
需求: 会匹配任意字符加上数字加上.jpg
匹配字符串: 1111111111111111111111111 (25 chars)
计算步骤数: 9187

例子2：
表达式：  .*\d+.*a
需求: 会匹配任意字符串加上数字加上任意字符串加上a字符
匹配字符串: 1111111111111111111111111 (25 chars)
计算步骤数: 77600

最典型的例子，重复运算符嵌套：
表达式： ^(a+)+$ 处理 aaaaaaaaaaaaaaaaX 将使正则表达式引擎分析65536个不同的匹配路径。

解决方案：

对正则表达式处理的内容应进行长度限制
消除正则表达式的歧义，避免重复运算符嵌套。例如表达式^(a+)+$应替换成^a+$

// 攻击者可以提交 lang 的内容为：
// en&user_id=1#
// 这将使攻击者可以随意篡改 user_id 的值

String lang = request.getParameter("lang");
GetMethod get = new GetMethod("http://www.host.com");

// 攻击者提交 lang=en&user_id=1#&user_id=123 可覆盖原始 user_id 的值
get.setQueryString("lang=" + lang + "&user_id=" + user_id);
get.execute();

解决方案1：

// 参数化绑定
URIBuilder uriBuilder = new URIBuilder("http://www.host.com/viewDetails");
uriBuilder.addParameter("lang", input);
uriBuilder.addParameter("user_id", userId);

HttpGet httpget = new HttpGet(uriBuilder.build().toString());

订单系统计算订单的价格
步骤1:
订单总价 = 商品1单价 * 商品1数量 + 商品2单价 * 商品2数量 + ...
步骤2:
钱包余额 = 钱包金额 - 订单总价

当攻击者将商品数量都篡改为负数，导致步骤1的订单总价为负数。而负负得正，攻击者不仅买入了商品并且钱包金额也增长了。

应在后台严格校验订单中每一个输入参数的长度、格式、逻辑、特殊字符以及用户的权限。

// jackson白名单过滤
ObjectMapper om = new ObjectMapper();
BasicPolymorphicTypeValidator validator = BasicPolymorphicTypeValidator.builder()

	// 信任 com.china. 包下的类
	.allowIfBaseType("com.china.")
	.allowIfSubType("com.china.")
	
	// 信任 Collection、Map 等基础数据结构
	.allowIfSubType(Collection.class)
	.allowIfSubType(Number.class)
	.allowIfSubType(Map.class)
	.allowIfSubType(Temporal.class)
	.allowIfSubTypeIsArray()
	.build();
om.activateDefaultTyping(validator,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

// 参考版本 springboot 2.3.2 
// pom.xml 配置参考 
<!-- 引入 actuator -->
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
	</dependency>

<!-- 引入 spring security -->
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-security</artifactId>
	</dependency>

// application.properties 配置参考
#路径映射
management.endpoints.web.base-path=/lhdmon
#允许访问的ip列表
management.access.iplist = 127.0.0.1,192.168.1.100,192.168.2.3/24,192.168.1.6
#指定端口
#management.server.port=8081
#关闭默认打开的endpoint
management.endpoints.enabled-by-default=false
#需要访问的endpoint在这里打开
management.endpoint.info.enabled=true
management.endpoint.health.enabled=true
management.endpoint.env.enabled=true
management.endpoint.metrics.enabled=true
management.endpoint.mappings.enabled=true
#sessions需要spring-session包的支持
#management.endpoint.sessions.enabled=true

#允许查询所有列出的endpoint
management.endpoints.web.exposure.include=info,health,env,metrics,mappings
#显示所有健康状态
management.endpoint.health.show-details=always

public void runCustomTrigger(String script) {
	ScriptEngineManager factory = new ScriptEngineManager();
	ScriptEngine engine = factory.getEngineByName("JavaScript");

	// 不执行安全校验，直接eval执行可能造成恶意的js代码执行
	engine.eval(script); 
}

解决方案：

java 8 或者 8 以上版本使用 delight-nashorn-sandbox 组件

<dependency>
    <groupId>org.javadelight</groupId>
    <artifactId>delight-nashorn-sandbox</artifactId>
    <version>[insert latest version]</version>
</dependency>

// 创建沙盒
NashornSandbox sandbox = NashornSandboxes.create();

// 沙盒内默认禁止js代码访问所有的java类对象
// 沙盒可以手工授权js代码能访问的java类对象
sandbox.allow(File.class);

// eval执行js代码
sandbox.eval("var File = Java.type('java.io.File'); File;")

public void runCustomTrigger(String script) {
	// 启用 Rhino 引擎的js沙盒模式
	SandboxContextFactory contextFactory = new SandboxContextFactory();
	Context context = contextFactory.makeContext();
	contextFactory.enterContext(context);
	try {
		ScriptableObject prototype = context.initStandardObjects();
		prototype.setParentScope(null);
		Scriptable scope = context.newObject(prototype);
		scope.setPrototype(prototype);

		context.evaluateString(scope,script, null, -1, null);
	} finally {
		context.exit();
	}
}

// 测试环境配置文件 application.properties 中
swagger.enable=true

// 生产环境配置文件 application.properties 中
swagger.enable=false

// java代码中变量 swaggerEnable 通过读取配置文件设置swagger开关
@Configuration
public class Swagger {
	@Value("${swagger.enable}")
	private boolean swaggerEnable;

	@Bean
	public Docket createRestApi() {
		return new Docket(DocumentationType.SWAGGER_2)
			//  变量 swaggerEnable 控制是否开启 swagger
			.enable(swaggerEnable)
			.apiInfo(apiInfo())
			.select()
			.apis(RequestHandlerSelectors.basePackage("com.tao.springboot.action"))
			//controller路径
			.paths(PathSelectors.any())
			.build();
    }

@Controller
class UserController {

	//禁止在url中使用业务变量，以防止篡改导致的越权
	@PostMapping("/user")
	public UserEntity getUser(@RequestParam("id") String id) {

	//返回用户所有字段内容，可能包括敏感字段
	return userService.findById(id).get(); 
	}
}

@Controller
class UserController {

	@InitBinder
	public void initBinder(WebDataBinder binder, WebRequest request){
		//限制返回给用户的字段
		binder.setAllowedFields(["username","password"]);
	}
}

解决方案2：

@Controller
class UserController {

	//禁止在url中使用业务变量，以防止篡改导致的越权
	@PostMapping("/user")
	public UserEntity getUser(@RequestParam("id") String id) {

	//返回用户所有字段内容，可能包括敏感字段
	return userService.findById(id).get(); 
	}
}

class UserEntity {

	@Id
	private Long id;
	private String username;

	// 如果使用jackson，可以使用@JsonIgnore禁止某字段参加格式化
	// 在某字段的get方法上使用@JsonIgnore对应禁止序列化，在set方法方法上使用@JsonIgnore对应禁止反序列化
	// 或者使用@JsonIgnoreProperties(value = "{password}")禁止某字段参与格式化
	@JsonIgnore
	private String password;
}

@javax.persistence.Entity
class UserEntity {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;

	private String username;

	private String password;

	private Long role;
}
@Controller
class UserController {

	@PutMapping("/user/")
	@ResponseStatus(value = HttpStatus.OK)
	public void update(UserEntity user) {

	// 攻击者可以构造恶意user对象，将id字段构造为管理员id，将password字段构造为弱密码
	// 如果鉴权不完整，接口读取恶意user对象的id字段后会覆盖管理员的password字段成为弱密码
	userService.save(user); 
	}
}

解决方案：

• setAllowedFields白名单

@Controller
class UserController {

	@InitBinder
	public void initBinder(WebDataBinder binder, WebRequest request){

		// 对允许绑定的字段设置白名单，阻止其他所有字段
		binder.setAllowedFields(["role"]); 
	}
}

@Controller
class UserController {

	@InitBinder
	public void initBinder(WebDataBinder binder, WebRequest request){

		// 对不允许绑定的字段设置黑名单，允许其他所有字段
		binder.setDisallowedFields(["username","password"]); 
	}
}

// 开启safeMode模式，完全禁用autoType。
1. 在代码中配置
    ParserConfig.getGlobalInstance().setSafeMode(true);
    如果使用new ParserConfig的方式，需要注意单例处理，否则会导致低性能full gc

2. 加上JVM启动参数
    -Dfastjson.parser.safeMode=true

3. 通过fastjson.properties文件配置。
    通过类路径的fastjson.properties文件配置，配置方式如下：
    fastjson.parser.safeMode=true

// 添加autotype白名单，添加白名单有三种方式
1. 在代码中配置，如果有多个包名前缀，分多次addAccept
    ParserConfig.getGlobalInstance().addAccept("com.hyit.pac.client.sdk.dataobject.");

2. 加上JVM启动参数，如果有多个包名前缀，用逗号隔开
    -Dfastjson.parser.autoTypeAccept=com.hyit.pac.client.sdk.dataobject.,com.cainiao. 

3. 通过类路径的fastjson.properties文件配置，如果有多个包名前缀，用逗号隔开safeMode模式
    fastjson.parser.autoTypeAccept=com.hyit.pac.client.sdk.dataobject.,com.cainiao. 

&#;`|*?~<>^()[]{}$\, \x0A 和 \xFF

INFO: Failed to parse val=twenty-one 
HACK: User logged in=badguy

然而，如果攻击者提交包含换行符%0d和%0a的字符串”twenty-one%0d%0aHACK:+User+logged+in%3dbadguy”，会记录以下条目：

INFO: Failed to parse val=twenty-one 
HACK: User logged in=badguy

public void risk(HttpServletRequest request, HttpServletResponse response) {
	String val = request.getParameter("val");
	try {
		int value = Integer.parseInt(val);
		out = response.getOutputStream();
	}
	catch (NumberFormatException e) {
		e.printStackTrace(out);
		log.info(""Failed to parse val = "" + val);
	}
}

public void risk(HttpServletRequest request, HttpServletResponse response) {
	String val = request.getParameter("val");
	try {
		int value = Integer.parseInt(val);
	}
	catch (NumberFormatException e) {
		val = val.replace("\r", "");
		val = val.replace("\n", "");
		log.info(""Failed to parse val = "" + val);
		//不要直接 printStackTrace 输出错误日志
	}
}

MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] resultBytes = md.digest(password.getBytes("UTF-8"));

StringBuilder stringBuilder = new StringBuilder();
for(byte b :resultBytes) {
	stringBuilder.append( Integer.toHexString( b & 0xFF ) );
}
return stringBuilder.toString();

对于上述功能，哈希值 “0x0679” 和 “0x6709” 都将输出为 “679”

解决方案：

stringBuilder.append(String.format("%02X", b));

jep290安全策略：全进程反序列化原则上使用白名单优先的设计模式，只有允许的类才能被反序列化，其它一律被阻止。

// 能被反序列化的流的限制
maxdepth=value // 单次反序列化堆栈最大深度
maxrefs=value  // 单次反序列化类的内部引用的最大数目
maxbytes=value // 单次反序列化输入流的字节数上限
maxarray=value // 单次反序列化输入流中数组数上限

// 以下示例介绍了限制反序列化的类名称的配置方法

// 允许唯一类 org.example.Teacher ，输入字节数最大为100，并阻止其它一切的类
jdk.serialFilter=maxbytes=100;org.example.Teacher;!*

// 允许 org.example. 下的所有类，输入字节数最大为100，并阻止其它一切的类
jdk.serialFilter=maxbytes=100;org.example.*;!*

// 允许 org.example. 下的所有类和子类，输入字节数最大为100，并阻止其它一切的类
jdk.serialFilter=maxbytes=100;org.example.**;!*

//允许一切类
jdk.serialFilter=*;

;    作为表达式的分隔符
.*   代表当前包下的所有类
.**  代表当前包下所有类和所有子类
！   代表取反，禁止匹配符号后的表达式被反序列化
*    通配符

jdk11+：%JAVA_HOME%\conf\security\java.security
 jdk8： %JAVA_HOME%\jre\lib\security\java.security

java -Djdk.serialFilter=org.example.**;maxbytes=100;!*

Properties props = System.getProperties();
props.setProperty("jdk.serialFilter", "org.example.**;maxbytes=100;!*");

String generateSecretToken() {
	Random r = new Random();
	return Long.toHexString(r.nextLong());
}

解决方案：

替换 java.util.Random 使用强度更高的 java.security.SecureRandom

import org.apache.commons.codec.binary.Hex;

String generateSecretToken() {
	SecureRandom secRandom = new SecureRandom();

	byte[] result = new byte[32];
	secRandom.nextBytes(result);
	return Hex.encodeHexString(result);
}

<user>
	<firstname>Ben</firstname>
	<lastname>Elmore</lastname>
	<loginID>abc</loginID>
	<password>test123</password>
</user>
<user>
	<firstname>Shlomy</firstname>
	<lastname>Gantz</lastname>
	<loginID>xyz</loginID>
	<password>123test</password>
</user>

则在XPath中其典型的查询语句如下：

//users/user[loginID/text()='xyz'and password/text()='123test']

正常用户传入 login 和 password，例如 loginID = 'xyz' 和 password = '123test'，则该查询语句将返回 true。但如果恶意用户传入类似 ' or 1=1 or ''=' 的值，那么该查询语句也会得到 true 返回值，因为 XPath 查询语句最终会变成如下代码：

//users/user[loginID/text()=''or 1=1 or ''='' and password/text()='' or 1=1 or ''='']

脆弱代码：

public int risk(HttpServletRequest request, 
		Document doc, XPath xpath ,org.apache.log4jLogger logger) {
	int len = 0;
	String path = request.getParameter("path");
	try {
		XPathExpression expr = xpath.compile(path);
		Object result = expr.evaluate(doc, XPathConstants.NODESET);
		NodeList nodes = (NodeList) result;
		len = nodes.getLength();
	} catch (XPathExpressionException e) {
		logger.warn("Exception", e);
	}
	return len;
}

public int fix(HttpServletRequest request, 
		Document doc, XPath xpath ,org.apache.log4j.Logger logger) {
	int len = 0;
	String path = request.getParameter("path");
	try {
		// 使用过滤函数
		String filtedXPath = filterForXPath(path);
		XPathExpression expr = xpath.compile(filtedXPath);
		Object result = expr.evaluate(doc, XPathConstants.NODESET);
		NodeList nodes = (NodeList) result;
		len = nodes.getLength();
	} catch (XPathExpressionException e) {
		logger.warn("Exception", e);
	}
	return len;
}
// 限制用户的输入数据，尤其应限制特殊字符
public String filterForXPath(String input) {
	if (input == null) {
		return null;
	}
	StringBuilder out = new StringBuilder();
	for (int i = 0; i < input.length(); i++) {
		char c = input.charAt(i);
		if (c >= 'A' && c <= 'Z') {
			out.append(c);
		} else if (c >= 'a' && c <= 'z') {
			out.append(c);
		} else if (c >= '0' && c <= '9') {
			out.append(c);
		} else if (c == '_' || c == '-') {
			//限制特殊字符的使用
			out.append(c);
		} else if (c >= 0x4e00 && c <= 0x9fa5) {
			//允许汉字使用
			out.append(c);
		}
	}
	return out.toString();
}

public void risk(HttpServletRequest request, HttpServletResponse response) {
	String val = request.getParameter("val");
	try {
		int value = Integer.parseInt(val);
	}
	catch (NumberFormatException e) {
		val = val.replace("\r", "");
		val = val.replace("\n", "");
		log.info(""Failed to parse val = "" + val);
		//不要直接 printStackTrace 输出错误日志
	}
}