目录
一、 SQL注入 3
-
普通查询 3
-
like查询 3
-
in语句 4
-
Order by /group by 语句 4
-
Hibernate框架 5
-
代码审计技巧 6
-
JAVA中常见数据库操作API 6
二、 XSS漏洞 12
-
JSP文件out.println 12
-
Controller返回字符串 14
-
XSS过滤器 15
-
代码审计技巧 21
三、 XXE漏洞 22
-
SAXReader类 22
-
常见XML处理接口 23
-
代码审计技巧 25
四、 URL跳转 26
-
常见URL跳转漏洞 26
-
代码审计技巧 27
五、 反序列化漏洞 28
1. JAVA反序列化漏洞 28
2. XML反序列化漏洞 29
3. 代码审计技巧 29
六、 命令注入 30
-
Runtime.getRuntime().exec() 30
-
代码审计技巧 31
七、 路径安全 32
-
常见路径安全 32
-
代码审计技巧 33
八、 文件上传 34
-
Apache tika 34
-
代码审计技巧 34
九、 CSRF 36
-
CSRF漏洞修复思路 36
-
代码审计技巧 39
十、 越权漏洞 40
-
平行越权 40
-
垂直越权 41
-
代码审计技巧 42
SQL注入
SQL注入攻击是黑客对数据库进行攻击的常用手段之一。随着B/S模式应用开发的发展,使用这种模式编写应用程序的程序员也越来越多。但是由于程序员的水平及经验也参差不齐,相当大一部分程序员在编写代码的时候,没有对用户输入数据的合法性进行判断,使应用程序存在安全隐患。用户可以提交一段数据库查询代码,根据程序返回的结果,获得某些他想得知的数据,这就是所谓的SQL Injection,即SQL注入。
普通查询
以Mybatis为例,下面的写法存在SQL注入漏洞
<select id="getUserById"parameterType="Integer"
resultType="User">
select * from user where id = ${id}
${ }是字符串替换, MyBatis在处理${ }时,它会将sql中的${ }替换为变量的值,传入的数据不会加两边加上单引号。
{ }是预编译处理,MyBatis在处理#{ }时,它会将sql中的#{ }替换为?,然后调用PreparedStatement的set方法来赋值,传入字符串后,会在值两边加上单引号。
所以正确的写法应该是
<select id="getUserById"parameterType="Integer"
resultType="User">
select * from user where id = #{id}
like查询
以下写法存在SQL注入漏洞
<select id="getUserBySearchName"parameterType="String"
resultType="User">
select * from user where username like '%${username}%'
同样是因为使用了${} 导致SQL注入漏洞,但是如果直接使用#{}运行时会爆错,如下图所示
所以正确的写法是:
<select id="getUserBySearchName"parameterType="String"
resultType="User">
select * from user where username like concat('%',#{username},'%')
in语句
与上述示例大概相同,直接使用#{}语法爆错,直接使用${}又存在SQL注入漏洞
<select id="getUserBySearchName"parameterType="String"
resultType="User">
select * from user where username in (#{username})
所以正确的写法应该如下:
<select id="getUserBySearchName"parameterType="String"
resultType="User">
select * from user where username in
<foreach collection="list"index="index"item="item"open="("
separator=","close=")">
{username}
Order by /group by 语句
与2、3相同,使用#{}会爆错,使用${}又存在SQL注入漏洞,但是这种情况下,无其它方法使用#{}形式,所以推荐的写法如下:
前端使用ID的形式传递到后台
ORDER BY id DESC
ORDER BY username DESC
ORDER BY sex DESC
在上下文中手动对SQL注入进行过滤
publicstaticString SecuritySQLI(String content) {
//根据关键字过滤
returncontent.replaceAll("(?i)select", "select").replaceAll("(?i)insert", "insert").replaceAll("(?i)update", "update").
replaceAll("(?i)delete", "delete").replaceAll("(?i)drop", "drop").replaceAll("(?i)create", "create").replaceAll("(?i)union", "union").
replaceAll("(?i)benchmark", "benchmark").replaceAll("(?i)sleep", "bleep").
replaceAll("(?i)substring", "substring").replaceAll("(?i)and", "and").replaceAll("(?)or", "or");
}
Hibernate框架
主要方法与Mybatis差不多,就是框架本身的API不太相同。几种常见场景的安全编码方式如下:
Query query=session.createQuery("from User user where user.name=:username and user:userage=:age ");
query.setString("username",username);
query.setInteger("userage",age);
Query query=session.createQuery("from User user where user.name=? and user:userage=? ");
query.setString(0,username);
query.setInteger(1,age);
Query query = session
.createQuery("select count(*) from Privilege p where p.name like ?");
query.setString(0, "%" + name + "%");
String hql = "from News n where n.title in (:titleList)";
Query query = session.createQuery(hql);
query.setParameter("titleList", dataList);
代码审计技巧
黑盒测试,扫描器一般都能直接扫出常见的SQL注入漏洞
快速定位到SQL语句代码片段,查看是否存在字符串拼接情况
搜索order by / group by 字符串,然后跟进变量查看是否有安全防护
Mybatis框架查看是否正确使用预编译方式执行SQL语句
Hibernate框架查看是否正确使用占位符等,是否存在HQL注入
JAVA中常见数据库操作API
JDBC常用API
DriverManager:用于管理JDBC驱动的服务类。主要功能是获取Connection对象
publicstaticConnection getConnection(String url, String user, String password)throwsSQLException
//该方法获得url对应数据库的连接
Connection :代表数据库连接对象。每一个Connection代表一个物理连接会话
Statement createStatement()throwsSQLException;
//该方法返回一个Statement对象
PreparedStatement prepareStatement(String sql)throwsSQLException;
//该方法返回预编译的Statement对象,即将SQL语句提交到数据库进行预编译
CallableStatement prepareCall(String sql)throwsSQLException;
//该方法返回CallableStatement对象,该对象用于调用存储过程
// 控制事务的相关方法
Savepoint setSavepoint()throwsSQLException
//创建一个保存点
Savepoint setSavepoint(String name)throwsSQLException;
//以指定名字来创建一个保存点;
voidsetTransactionIsolation(intlevel)throwsSQLException;
//设置事务的隔离级别;
voidrollback()throwsSQLException;
//回滚事务;
voidrollback(Savepoint savepoint)throwsSQLException;
//将事务回滚到指定的保存点;
voidsetAutoCommit(booleanautoCommit)throwsSQLException;
//关闭自动提交,打开事务;
voidcommit()throwsSQLException;
//提交事务;
Statement :用于执行SQL语句的工具接口。该对象既可以执行DDL,DCL语句,也可以执行DML语句,还可以用于执行SQL查询
ResultSet executeQuery(String sql)throwsSQLException;
//该方法用于执行查询语句,并返回查询结果对应ResultSet对象。该方法只能用于执行查询语句
intexecuteUpdate(String sql)throwsSQLException;
//该方法用于执行DML语句,并返回受影响的行数;该方法也可用于执行DDL语句,执行DDL语句将返回0
booleanexecute(String sql)throwsSQLException;
//改方法可以执行任何sql语句。如果执行后第一个结果为ResultSet对象,则返回true;如果执行后第一个结果为受影响的行数或没有任何结果,则返回false
PreparedStatement :预编译的Statement对象,它允许数据库预编译sql语句,以后每次只改变sql 命令的参数,避免数据库每次都需要编译sql语句,无需再传入sql语句,它比Statement多了以下方法
voidsetXxx(intparameterIndex, Xxx value):
//该方法根据传入参数值的类型不同,需要使用不同的方法。传入的值根据索引传给sql语句中指定位置的参数
Hibernate框架常用API
Configuration :负责Hibernate的配置信息。包括运行的底层信息:数据库的URL、用户名、密码、JDBC驱动类,数据库Dialect,数据库连接池等 和持久化类与数据表的映射关系(*.hbm.xml文件)
//属性文件(hibernate.properties):
Configuration cfg =newConfiguration();
//Xml文件(hibernate.cfg.xml)
Configuration cfg =newConfiguration().configure();
SessionFactory :Configuration对象根据当前的配置信息生成SessionFactory对象,SessionFactory 对象中保存了当前数据库的配置信息和所有映射关系以及预定义的SQL语句,同时还负责维护 Hibernate的二级缓存
SessionFactory configuration.buildSessionFactory()
//获取SessionFactory对象
Session sessionFactory.openSession()
//获取Session对象
Session :是应用程序与数据库之间交互操作的单线程对象。session对象有一个一级缓存,显式执行flush之前,所有的持久层操作的数据都缓存在session对象处。相当于JDBC的Connection
//获取持久化对象方法分为get()和load()
publicObject get(Class clazz, Serializable id);
//通过持久化类和主键获取对象
publicObject get(Class clazz, Serializable id, LockOptions lockOptions);
//通过持久化类和主键、锁选项获取对象
publicObject get(String entityName, Serializable id);
//通过全类名+主键获取对象
publicObject get(String entityName, Serializable id, LockOptions lockOptions);
//通过全类名+主键+锁选项获取对象
//load()方法与get()相同,但多了下列方法
publicvoidload(Object object, Serializable id);
//通过一个空的持久化类的实例+主键获取对象
//get方法会在调用之后立即向数据库发出sql语句(不考虑缓存的情况下),返回持久化对象;
//而load方法会在调用后返回一个代理对象,该代理对象只保存了实体对象的id,直到使用对象的非主键属性时才会发出sql语句.
//查询数据库中不存在的数据时,get方法返回null,load方法抛出异常:org.hibernate.ObjectNotFoundException
Serializable save(Object object)
//保存持久化对象
voidupdate(Object object)
//更新持久化对象
voiddelete(Object object)
//删除持久化对象
voidsaveOrUpdate(Object object)
//根据ID判断是save还是update,如果id存在,则为update,若id不存在,即为save
Query createQuery(String hql)
//执行HQL查询
SQLQuery createSQLQuery(String sql)
//执行SQL查询
Transaction beginTransaction()
//开启事务
Transaction :具有数据库事务的概念,所有持久层都应该在事务管理下进行,即使是只读操作
voidcommit()
//提交相关联的session实例
voidrollback()
//撤销事务操作
booleanwasCommitted()
//检查事务是否提交
Query :用于从数据存储源查询对象及控制执行查询的过程,Query对象包装了一个HQL查询语句。Query对象在session对象关闭之前有效,否则会抛出Sessionexception异常
Query setxxx()
//用于设置HQL语句中问号或者变量的值
List list()
//返回查询结果,并把查询结果转换成list对象
Obect uniqueResult()
//得到一个单个的对象(查询结果仅一条)
intexecuteUpdate()
//执行更新或删除语句
SpringJdbc常用API
JdbcTemplate : Spring对JDBC最低级别的封装,其他的工作模式 事实上在底层使用了JdbcTemplate 作为其底层的实现基础
voidexecute(String sql)
//用于执行任何SQL语句,一般执行DDL语句
intupdate(String sql)
//用于执行新增,修改,删除等语句。
int[] batchUpdate(String sql)
int[] batchUpdate(String sql,BatchPreparedStatementSetter pss)
//批量执行SQL语句
queryForxxxxx(String sql)
//执行查询相关的语句
Map call(CallableStatementCreator csc, List declaredParameters)throwsDataAccessException
//执行存储过程、函数相关的语句
NamedParameterJdbcTemplate :对JdbcTemplate做了封装,提供了更加便捷的基于命名参数的使用方式
String sql = "INSERT INTO student(id,student_name,email,Dept_No) VALUES(:id,:name,:email,:deptid)";
Map paramMap =newHashMap<>();
paramMap.put("id",9);
paramMap.put("name","Limbo");
paramMap.put("email","1610770854@qq.com");
paramMap.put("deptid",1);
namedParameterJdbcTemplate.update(sql,paramMap);
Mybatis常用API
SqlSessionFactory :是单个数据库映射关系经过编译后的内存镜像,其主要作用是创建SqlSession对象
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory =newSqlSessionFactoryBuilder().build(inputStream);
SqlSession openSession();
SqlSession openSession(Connection connection);
SqlSession :应用程序与持久层之间执行交互操作的一个单线程对象,其主要作用是执行持久化操作
voidcommit()
//提交事务
intdelete(String statement)
intdelete(String statement, Object parameter)
//执行一条删除操作
intinsert(String statement)
intinsert(String statement, Object parameter)
//执行一条插入操作
T selectOne(String statement)
T selectOne(String statement, Object parameter)
//执行一条查询,并返回一条记录
List selectList(String statement)
List selectList(String statement, Object parameter)
//执行一条查询,返回List对象
T getMapper(Class type)
//获取一个Mapper对象
Spring data JPA
Spring Data JPA 简化持久层开发大致需要如下三个步骤
publicinterfaceUserRepositoryextendsRepository { }
在持久层的接口中声明需要的业务方法,Spring Data JPA将会根据指定的策略为该方法生成实现代码。用户不需要实现该接口
List findByLastname(String lastname);
在Spring的配置文件中添加配置,为声明的接口设定代理对象
获得并使用repository的实例
//在Spring Container中使用
publicclassTestJPA {
@Autowired
privateUserRepository repository;
publicvoiddoSomething() {
User u =newUser();
User user = repository. save (u);
}
}
//在Spring Container外使用
RepositoryFactorySupport factory = … // Instantiate factory here
UserRepository repository = factory.getRepository(UserRepository.class)
Respository :是SpringData的核心接口,并不提供任何方法,用户需要自己定义需要的方法
publicinterfaceUserDaoextendsRepository {}
@RepositoryDefinition(domainClass = User.class, idClass = Long.class)
publicinterfaceUserDao {}
XSS漏洞
XSS攻击通常指的是通过利用网页开发时留下的漏洞,通过巧妙的方法注入恶意指令代码到网页,使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript,但实际上也可以包括Java、 VBScript、ActiveX、 Flash 或者甚至是普通的HTML。攻击成功后,攻击者可能得到包括但不限于更高的权限(如执行一些操作)、私密网页内容、会话和cookie等各种内容。
JSP文件out.println
<%@ page language="java"import="java.util.*"pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
欢迎,<% out.println(request.getParameter("username")); %> 回来
JSP文件将请求参数直接显示在页面,这种场景现在出现较少,应该避免出现这种情况,如果碰到了,可以参考以下代码暂时减少危害
<%@ page language="java"import="java.util.,java.lang."pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>
<%!
String html(String input) {
intlength = input.length();
StringBuilder output =newStringBuilder(length);
for(inti = 0; i < length; i++) {
charc = input.charAt(i);
switch(c) {
// Control chars
case'\t':
output.append(" ");
break;
case'\n':
output.append(" ");
break;
case'\f':
output.append("");
break;
case'\r':
output.append(" ");
break;
// Chars that have a meaning for HTML
case'\'':
output.append("'");
break;
case'\':
output.append("\");
break;
case' ':
output.append(" ");
break;
case'/':
output.append("/");
break;
case'"':
output.append(""");
break;
case'<':
output.append("<");
break;
case'>':
output.append(">");
break;
case'&':
output.append("&");
break;
// Unicode new lines
case'\u2028':
output.append(" ");
break;
case'\u2029':
output.append(" ");
break;
default:
output.append(c);
break;
}
}
returnoutput.toString();
}%>
欢迎,<% out.println(html(request.getParameter("username")));%>回来
Controller返回字符串
以根据ID查询用户为例,以下代码可能存在XSS漏洞
@RequestMapping("/getUserById")
publicString getUserById(Integer id, Model model) {
System.out.println(id);
User user = userService.getUserById(id);
System.out.println(user.toString());
model.addAttribute("user",user);
return"user";
}
执行的结果如下图所求:
再转到user.jsp中查看输出
发现Controller在返回user对象时直接输出,未做任何过滤,所以当请求到id=2时即会产生XSS漏洞。
正确的写法建议如下:在输出之前将字段值使用org.springframework.web.util.HtmlUtils.htmlEscape()进行HTML实体编码后再输出
@RequestMapping("/getUserById")
publicString getUserById(Integer id, Model model) {
User user = userService.getUserById(id);
System.out.println(user.toString());
user.setUsername(HtmlUtils.htmlEscape(user.getUsername()));
user.setJob(HtmlUtils.htmlEscape(user.getJob()));
model.addAttribute("user",user);
return"user";
}
org.springframework.web.util.HtmlUtils.htmlEscape() 实体编码
org.springframework.web.util.HtmlUtils.htmlUnescape() 实体解码
XSS过滤器
数据库中原本就是脏数据的场景比较少,一般都是来源于用户输入再入库,而在输出时进行编码工作量大,并且容易疏漏,所以一般使用过滤器,将输入内容在入库之前自动进行编码操作。
Web.xml中配置过滤器
xssFilter
com.luozheng.filter.SecurityFilter
xssFilter
*
在com.luozheng.filter包中编写过滤器代码
packagecom.luozheng.filter;
importjava.io.IOException;
importjavax.servlet.Filter;
importjavax.servlet.FilterChain;
importjavax.servlet.FilterConfig;
importjavax.servlet.ServletException;
importjavax.servlet.ServletRequest;
importjavax.servlet.ServletResponse;
importjavax.servlet.http.HttpServletRequest;
publicclassSecurityFilterimplementsFilter {
@Override
publicvoidinit(FilterConfig filterConfig)throwsServletException {
}
@Override
publicvoiddoFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throwsIOException, ServletException {
SecurityHttpWrapper securityRequest =newSecurityHttpWrapper((HttpServletRequest) request);
chain.doFilter(securityRequest, response);
}
@Override
publicvoiddestroy() {
}
}
过滤器重写了父类的doFilter()方法,自定义了SecurityHttpWrapper 类
package com.luozheng.filter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import com.luozheng.util.SecurityUtil;
/**
*
- @author luozheng
*
*/
public class SecurityHttpWrapper extends HttpServletRequestWrapper {
public static boolean rx(String str, Pattern pattern) {
Matcher matcher = pattern.matcher(str);
boolean b = matcher.find();
return b;
}
private static class SecurityRegex {
static Pattern[] XSS_REG = null;
static Pattern[] SQLI_REG = null;
static Pattern[] RCE_REG = null;
static Pattern[] whiteListURLs = null;
static Pattern[] blackListURLs = null;
static {
String[] XSSREG = {};
String[] SQLIREG = {};
String[] RCEREG = { "xwork\.MethodAccessor|java\.lang" };
String[] WLREG = {};
String[] BLREG = {};
XSS_REG = new Pattern[XSSREG.length];
SQLI_REG = new Pattern[SQLIREG.length];
RCE_REG = new Pattern[RCEREG.length];
whiteListURLs = new Pattern[WLREG.length];
blackListURLs = new Pattern[BLREG.length];
for (int i = 0; i < XSSREG.length; i++) {
XSS_REG[i] = Pattern.compile(XSSREG[i], Pattern.CASE_INSENSITIVE);
}
for (int i = 0; i < SQLIREG.length; i++) {
SQLI_REG[i] = Pattern.compile(SQLIREG[i], Pattern.CASE_INSENSITIVE);
}
for (int i = 0; i < RCEREG.length; i++) {
RCE_REG[i] = Pattern.compile(RCEREG[i], Pattern.CASE_INSENSITIVE);
}
for (int i = 0; i < WLREG.length; i++) {
whiteListURLs[i] = Pattern.compile(WLREG[i], Pattern.CASE_INSENSITIVE);
}
for (int i = 0; i < BLREG.length; i++) {
blackListURLs[i] = Pattern.compile(BLREG[i], Pattern.CASE_INSENSITIVE);
}
}
}
private HttpServletRequest orgRequest;
public SecurityHttpWrapper(HttpServletRequest request) {
super(request);
orgRequest = request;
}
/**
-
覆盖getParameter方法,将参数名和参数值都做xss过滤。
-
如果需要获得原始的值,则通过super.getParameterValues(name)来获取
-
getParameterNames,getParameterValues和getParameterMap也可能需要覆盖
*/
@Override
public String getParameter(String name) {
Boolean flag = false;
String value = super.getParameter(name);
String path = getRequestURI();
// whitelist
if (SecurityRegex.whiteListURLs.length != 0) {
for (int i = 0; i < SecurityRegex.whiteListURLs.length; i++) {
flag = rx(path, SecurityRegex.whiteListURLs[i]);
if (flag) {
return value;
}
}
}
// blacklist
if (SecurityRegex.blackListURLs.length != 0) {
for (int i = 0; i < SecurityRegex.blackListURLs.length; i++) {
flag = rx(path, SecurityRegex.blackListURLs[i]);
if (flag) {
return "";
}
}
}
if (value != null) {
// sqli filter
for (int i = 0; i < SecurityRegex.SQLI_REG.length; i++) {
flag = rx(value, SecurityRegex.SQLI_REG[i]);
if (flag) {
System.out.print("alert");
return "";
}
}
// xss filter
for (int i = 0; i < SecurityRegex.XSS_REG.length; i++) {
flag = rx(value, SecurityRegex.XSS_REG[i]);
if (flag)
return SecurityUtil.SecurityXssScript(value);
}
// rec filter
for (int i = 0; i < SecurityRegex.RCE_REG.length; i++) {
flag = rx(value, SecurityRegex.RCE_REG[i]);
if (flag) {
System.out.print("alert");
return "";
}
}
}
return value;
}
/**
-
覆盖getHeader方法,将参数名和参数值都做xss过滤
-
如果需要获得原始的值,则通过super.getHeaders(name)来获取getHeaderNames也可能需要覆盖
*/
@Override
public String getHeader(String name) {
Boolean flag = false;
String value = super.getHeader(name);
String path = getRequestURI();
// whitelist
if (SecurityRegex.whiteListURLs.length != 0) {
for (int i = 0; i < SecurityRegex.whiteListURLs.length; i++) {
flag = rx(path, SecurityRegex.whiteListURLs[i]);
if (flag) {
return value;
}
}
}
// blacklist
if (SecurityRegex.blackListURLs.length != 0) {
for (int i = 0; i < SecurityRegex.blackListURLs.length; i++) {
flag = rx(path, SecurityRegex.blackListURLs[i]);
if (flag) {
return "";
}
}
}
if (value != null) {
// sqli filter
for (int i = 0; i < SecurityRegex.SQLI_REG.length; i++) {
flag = rx(value, SecurityRegex.SQLI_REG[i]);
if (flag) {
System.out.print("alert");
return "";
}
}
// xss filter
for (int i = 0; i < SecurityRegex.XSS_REG.length; i++) {
flag = rx(value, SecurityRegex.XSS_REG[i]);
if (flag)
return SecurityUtil.SecurityXssScript(value);
}
// rec filter
for (int i = 0; i < SecurityRegex.RCE_REG.length; i++) {
flag = rx(value, SecurityRegex.RCE_REG[i]);
if (flag) {
System.out.print("alert");
return "";
}
}
}
return value;
}
/**
- 获取最原始的request
*
- @return
*/
public HttpServletRequest getOrgRequest() {
return orgRequest;
}
/**
- 获取最原始的request的静态方法
*
- @return
*/
public static HttpServletRequest getOrgRequest(HttpServletRequest req) {
if (req instanceof SecurityHttpWrapper) {
return ((SecurityHttpWrapper) req).getOrgRequest();
}
return req;
}
}
该类中将request的getParameter() 方法、getHeader() 方法获取的参数自动进行了编码处理再传递到业务代码中。
代码审计技巧
首先查看web.xml文件中是否存在全局XSS过滤器
JSP页面搜索out关键字,查看输出
查看所有HttpServletRequest 类的上下文环境
在Controller中查找输出信息,输出位置等
XXE漏洞
XXE漏洞是针对应用程序解析XML输入类型的攻击。当弱配置的XML解析器处理包含对外部实体的引用的XML输入时,就会发生此攻击。这种攻击可能导致泄露机密数据,拒绝服务,伪造服务器端请求,从解析器所在的计算机的角度进行端口扫描以及其他系统影响。
SAXReader类
SAXReader读取xml内容
publicvoidXMLUtil(String path) {
try{
SAXReader reader =newSAXReader();
Document document = reader.read(newFile(path));
Element root = document.getRootElement();
List list = root.elements();
for(Element element : list) {
System.out.println(element.getName() + " : " + element.getText());
}
}catch(DocumentException e) {
e.printStackTrace();
}
}
当xml内容为
%d;] >
1
张三
26
男
3000
执行时即会向目标地址发送http请求
正确的写法应该为
SAXReader reader =newSAXReader();
reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
reader.setFeature("http://xml.org/sax/features/external-general-entities",false);
reader.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
常见XML处理接口
这里列举了一些常见的XML处理接口
javax.xml.parsers.DocumentBuilder
javax.xml.stream.XMLInputFactoryr
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.parsers.SAXParser
org.dom4j.io.SAXReader
org.xml.sax.XMLReader
javax.xml.transform.sax.SAXSource
javax.xml.transform.TransformerFactory
javax.xml.transform.sax.SAXTransformerFactory
javax.xml.validation.SchemaFactory
javax.xml.bind.Unmarshaller
javax.xml.xpath.XPathExpression
javax.xml.parsers.DocumentBuilder
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setAttribute("http://apache.org/xml/features/disallow-doctype-decl",true);
dbf.setAttribute("http://xml.org/sax/features/external-general-entities",false);
dbf.setAttribute("http://xml.org/sax/features/external-parameter-entities",false);
dbf.setAttribute("http://apache.org/xml/features/nonvalidating/load-external-dtd",false);
dbf.setAttribute(XMLConstants.FEATURE_SECURE_PROCESSING,true);
dbf.setExpandEntityReferences(false);
DocumentBuilder db = dbf.newDocumentBuilder();
javax.xml.stream.XMLInputFactory
XMLInputFactory xif = XMLInputFactory.newInstance();
xif.setProperty(XMLInputFactory.SUPPORT_DTD,false);
xif.setProperty("javax.xml.stream.isSupportingExternalEntities",false);
XMLStreamReader reader = xif.createXMLStreamReader(newFileInputStream(newFile(path)));
org.jdom.input.SAXBuilder
SAXBuilder saxBuilder =newSAXBuilder();
saxBuilder.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
saxBuilder.setFeature("http://xml.org/sax/features/external-general-entities",false);
saxBuilder.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
org.jdom2.Document build = saxBuilder.build(newFile(path));
javax.xml.parsers.SAXParser
SAXParserFactory spf =SAXParserFactory.newInstance();
spf.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
spf.setFeature("http://xml.org/sax/features/external-general-entities",false);
spf.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
SAXParser parser =spf.newSAXParser();
MyDefaultHandler myHandler =newMyDefaultHandler();
org.xml.sax.XMLReader
FileReader fileReader =newFileReader(path);
XMLReader parser = XMLReaderFactory.createXMLReader();
parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd",false);
parser.setFeature("http://xml.org/sax/features/external-general-entities",false);
parser.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
代码审计技巧
XML解析一般在配置文件导入、数据传输等接口可能会涉及,凡是涉及到XML解析的场景中XML解析器是否禁用外部实体,从而判断是否存在XXE。
解析其它特殊文件场景也可能存在XXE漏洞,比如在线打开Office文件,上传Office文件等。
也可根据项目导入的JAR包,再全局搜索对应XML解析包中的关键API,找到对应的业务代码进行审计。
URL跳转
Web应用程序接受用户控制的输入,该输入指定到外部站点的链接,并在重定向中使用该链接。HTTP参数可能包含URL值,并且可能导致Web应用程序将请求重定向到指定的URL。通过将URL值修改为恶意站点,攻击者可以成功启动网络钓鱼诈骗并窃取用户凭据。由于修改后的链接中的服务器名称与原始站点相同,因此大大提高了网络钓鱼攻击的成功率。
常见URL跳转漏洞
一般URL跳转的参数名叫做url、host、redirect等,下面以SpringMVC为例,常见的错误写法为将获取到的参数未经验证直接传入redirect: 中
@RequestMapping("/redirect")
publicString listUser(HttpServletRequest request,Model model) {
String url = request.getParameter("url");
return"redirect:"+url;
}
一般在这种功能场景中,我们需要限制redirect跳转的域名为白名单列表中的域名,或者给个页面交由用户点击确认后再跳转。下面以检查域名是否在白名单列表中为示例:
@RequestMapping("/redirect")
publicString listUser(HttpServletRequest request,Model model) {
List whiteUrls =newArrayList();
whiteUrls.add("baidu.com");
whiteUrls.add("qq.com");
whiteUrls.add("163.com");
String url = request.getParameter("url");
try{
URL u =newURL(url);
String host = u.getHost();
String[] hostSplit = host.split("\.");
host = hostSplit[hostSplit.length-2] + "." + hostSplit[hostSplit.length-1] ;
if(whiteUrls.contains(host)) {
return"redirect:"+url;
}
}catch(MalformedURLException e) {
e.printStackTrace();
}
return"redirect:/";
}
代码审计技巧
全局搜索redirect、forward、sendRedirect、Location 关键字
关注验证身份登陆后的URL跳转
反序列化漏洞
序列化是指把对象转换为字节序列的过程,而反序列化是指把字节序列恢复为对象的过程。对象序列化的最主要的用处就是在传递和保存对象的时候,保证对象的完整性和可传递性。序列化是把对象转换成有序字节流,以便在网络上传输或者保存在本地文件中。
反序列化就是客户端从文件中或网络上获得序列化后的对象字节流后,根据字节流中所保存的对象状态及描述信息,通过反序列化重建对象。
JAVA反序列化漏洞
在JAVA语言中只有实现了Serializable和Externalizable接口的类的对象才能被序列化,Java程序使用ObjectInputStream对象的readObject方法将反序列化数据转换为java对象。但当输入的反序列化的数据可被用户控制,那么攻击者即可通过构造恶意输入,让反序列化产生非预期的对象,在此过程中执行构造的任意代码。
常见代码示例:
//读取输入流,并转换对象
InputStream in = request.getInputStream();
ObjectInputStream ois =newObjectInputStream(in);
//恢复对象
ois.readObject();
ois.close();
上述代码中,程序读取输入流并将其反序列化为对象,此时如果项目中存在一些能被反序列化漏洞利用的第三方库(详情参见 ysoserial ),此时即可构造特定反序列化对象实现任意代码执行。
此处推荐项目中添加commons-io包
commons-io
commons-io
2.6
利用Commons IO Serialization包中的ValidatingObjectInputStream类的accept方法来实现反序列化类白/黑名单控制,参考下面示例
InputStream in = request.getInputStream();
ObjectInputStream ois =newObjectInputStream(in);
ValidatingObjectInputStream vois =newValidatingObjectInputStream(ois);
//只允许反序列化SerialObject class
vois.accept(SerialObject.class);
Object obj = vois.readObject();
vois.close();
并且存在漏洞版本的第三方库也需要更新至最新版。
XML反序列化漏洞
存在一些场景是将JAVA对象与XML文件相互转化,除了上面提到的XXE漏洞外,还有可能存在XML反序列化漏洞
publicvoidXMLDecoder(String path) {
try{
File file =newFile(path);
FileInputStream fis =newFileInputStream(file);
BufferedInputStream bis =newBufferedInputStream(fis);
XMLDecoder xd =newXMLDecoder(bis);
xd.readObject();
xd.close();
}catch(FileNotFoundException e) {
e.printStackTrace();
}
}
如果被反序列化的XML文件被用户可控,即会执行相应的恶意命令
calc此XMLDecoder反序列化漏洞影响JDK 1.4~JDK 11,所以此处建议不使用该API。
代码审计技巧
查找项目依赖JAR包,查看是否引用了第三方存在漏洞的JAR包
全局搜索XMLDecoder关键字,查找XML反序列化入口点
全局搜索 readObject、readExternal关键字,查找反序列对象入口点
命令注入
命令注入攻击是通过易受攻击的应用程序在主机操作系统上执行任意命令。当应用程序将用户提供的不安全数据(表格,cookie,HTTP标头等)传递到系统command时,可能会发生命令注入攻击。在这种攻击中,攻击者提供的操作系统命令通常是在易受攻击的应用程序的特权下执行的。由于没有足够的输入验证,因此可能发生命令注入攻击。
Runtime.getRuntime().exec()
一般JAVA程序中除了框架本身的命令执行漏洞外,很少有命令执行漏洞。
JAVA调用系统命令的示例如下:
@RequestMapping("command")
publicString execCommand(HttpServletRequest request,Model model)throwsIOException {
String cmd = request.getParameter("cmd");
Process process = Runtime.getRuntime().exec(new String[] {"cmd","/c",cmd});
InputStream is = process.getInputStream();
BufferedReader br =newBufferedReader(newInputStreamReader(is,"UTF-8"));
StringBuffer sb =newStringBuffer();
while(br.read()!= -1) {
sb.append(br.readLine());
}
model.addAttribute("CMDResult", sb);
return"exec";
}
执行效果图如下:
对于这种直接调用Runtime.getRuntime().exec( cmd)这个API的可以参考 OWASP ESAPI项目对cmd参数进行编码,防止使用 & 、&&、;、|、||符号进行命令注入。即在Windows环境下将需要执行的命令每个字符前面加上”^”符号,在Linux/Unix环境中将需要执行的命令每个字符前面加上”\”字符,就可以解决命令注入漏洞了。
代码示例如下:
publicstaticString WindowsCodec(String cmd) {
char[] charArray = cmd.toCharArray();
StringBuffer sb =newStringBuffer();
for(inti = 0; i < charArray.length; i++) {
sb.append("^" + charArray[i]);
}
returnsb.toString();
}
publicstaticString UnixCodec(String cmd) {
char[] charArray = cmd.toCharArray();
StringBuffer sb =newStringBuffer();
for(inti = 0; i < charArray.length; i++) {
sb.append("\" + charArray[i]);
}
returnsb.toString();
}
代码审计技巧
全局搜索Runtime、ProcessBuilder、getruntime、exec等关键字
查找项目依赖JAR包,查看是否引用了第三方自带命令执行的JAR包,如beanshell
路径安全
根据Java API[API 2006]文档中对java.io.File类的描述:
一个路径名,不管是抽象的还是字符串形式,可以是相对路径也可以是绝对路径。使用绝对路径名因为在定位一个路径表示的文件时,已经不需要其他信息了,因而可以认为是完整的。相比之下,一个相对路径名必须要增加其他的路径信息才能进行解释。
绝对路径名或者相对路径名会包含文件链接,比如符号链接、硬链接、快捷方式、影子、别名和联名。这些文件链接在文件验证操作进行之前必须完全解析。例如,一个命名为trace的符号链接最终可以是指向路径名/home/system/trace ,该路径名可能同时会包含特殊的文件名,这些文件名会让验证变得困难。
标准化文件名比验证路径名要容易得多,很多路径会指向一个目录或文件。此外,当需要限制用户访问在某个特定目录的文件,或者需要基于文件名者路径名的时候,需要做出对应的安全策略。通常这些限制会被攻击者利用目录遍历/等价路径这样的方式绕过,而产生漏洞。
常见路径安全
不安全的文件路径可能会导致黑客通过使用../绕过原本程序限制,导致任意文件读取/下载,或者上传文件至任意目录等。
漏洞代码如下:
File file =newFile("../../windows/win.ini");
String path = file.getAbsolutePath();
//限定目录
String limit = "C:\Users\luozheng\eclipse-workspace\vulnSSM";
if(path.startsWith(limit)) {
…………
}
如上图所示,通过../拼接文件路径绕过目录限制,正确的代码如下:
File file =newFile("../../windows/win.ini");
String path = file.getCanonicalPath();
//限定目录
String limit = "C:\Users\luozheng\eclipse-workspace\vulnSSM";
if(path.startsWith(limit)) {
System.out.println("路径穿越");
}else{
System.out.println("安全");
}
代码审计技巧
全局搜索关键字getAbsolutePath、getPath关键字
检查对文件操作的方法中是否有对 “.(点)”、“..(点点)”进行过滤处理
查看是否开启Java 安全管理器 permission Java.io.FilePermission
文件上传
上传文件过程中,后台程序代码经常是未校验上传文件的内容格式和文件后缀,导致黑客可上传jsp文件等,导致服务器被getShell。
Apache tika
在编码时,需要考虑文件内容格式是否存在白名单范围内,并且上传后文件名有系统根据文件格式自动重命名。这里推荐使用Apache tika开源库来识别上传的文件格式,示例代码如下:
publicbooleanFileCheck(File file) {
// 白名单,仅允许这些文件通过检查
String[] whiteList = { "image/png", "image/jpeg", "text/plain" };
try{
Parser parser =newAutoDetectParser();
Metadata metadata =newMetadata();
metadata.set(Metadata.RESOURCE_NAME_KEY, file.getName());
ContentHandler handler =newBodyContentHandler();
InputStream is =newFileInputStream(file);
parser.parse(is, handler, metadata,newParseContext());
// CONTENTTYPE 即tika库识别出file的文件类型
String CONTENTTYPE = metadata.get(Metadata.CONTENT_TYPE);
if(Arrays.binarySearch(whiteList, CONTENTTYPE) != -1) {
returntrue;
}
}catch(Exception e) {
e.printStackTrace();
}
returnfalse;
}
检查完文件类型后,需要对文件进行重命名,建议以文件MD5+时间戳为文件名
代码审计技巧
检查上传文件操作中是否有对文件格式、后缀进行白名单或黑名单限制(白名单优先)
检查上传文件操作中是否有对上传的文件大小进行限制(文件太大会造成DoS攻击 )
全局搜索上传文件关键字MultipartFile
模糊搜索文件上传类或函数,如FileUpLoadServlet、FileUploadHandle
CSRF
CSRF跨站点请求伪造(Cross—Site Request Forgery),跟XSS攻击一样,存在巨大的危害性,你可以这样来理解:
攻击者盗用了你的身份,以你的名义发送恶意请求,对服务器来说这个请求是完全合法的,但是却完成了攻击者所期望的一个操作,比如以你的名义发送邮件、发消息,盗取你的账号,添加系统管理员,甚至于购买商品、虚拟货币转账等。
CSRF漏洞修复思路
一般CSRF修复方法就是在关键操作中加入token字段,具体流程如下:
跳转页面前生成随机token,并存放在session中
form中将token放在隐藏域中,保存时将token放头部一起提交
获取头部token, 与session中的token比较,一致则通过
生成新的token,并传给前端
配置拦截器
拦截器实现 CSRFInterceptor.java
/**
- CSRFInterceptor 防止跨站请求伪造拦截器
*/
public class CSRFInterceptor extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("---------->" + request.getRequestURI());
System.out.println(request.getHeader("X-Requested-With"));
// 提交表单token 校验
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
VerifyCSRFToken verifyCSRFToken = method.getAnnotation(VerifyCSRFToken.class);
// 如果配置了校验csrf token校验,则校验
if (verifyCSRFToken != null) {
// 是否为Ajax标志
String xrq = request.getHeader("X-Requested-With");
// 非法的跨站请求校验
if (verifyCSRFToken.verify() && !verifyCSRFToken(request)) {
if (StrUtil.isEmpty(xrq)) {
// form表单提交,url get方式,刷新csrftoken并跳转提示页面
String csrftoken = CSRFTokenUtil.generate(request);
request.getSession().setAttribute("CSRFToken", csrftoken);
response.setContentType("application/json;charset=UTF-8");
PrintWriter out = response.getWriter();
out.print("非法请求");
response.flushBuffer();
return false;
} else {
// 刷新CSRFToken,返回错误码,用于ajax处理,可自定义
String csrftoken = CSRFTokenUtil.generate(request);
request.getSession().setAttribute("CSRFToken", csrftoken);
ResultCode rc = CodeConstant.CSRF_ERROR;
response.setContentType("application/json;charset=UTF-8");
PrintWriter out = response.getWriter();
out.print(JSONObject.toJSONString(rc));
response.flushBuffer();
return false;
}
}
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
throws Exception {
// 第一次生成token
if (modelAndView != null) {
if (request.getSession(false) == null || StrUtil.isEmpty((String) request.getSession(false).getAttribute("CSRFToken"))) {
request.getSession().setAttribute("CSRFToken", CSRFTokenUtil.generate(request));
return;
}
}
// 刷新token
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
RefreshCSRFToken refreshAnnotation = method.getAnnotation(RefreshCSRFToken.class);
// 跳转到一个新页面 刷新token
String xrq = request.getHeader("X-Requested-With");
if (refreshAnnotation != null && refreshAnnotation.refresh() && StrUtil.isEmpty(xrq)) {
request.getSession().setAttribute("CSRFToken", CSRFTokenUtil.generate(request));
return;
}
// 校验成功 刷新token 可以防止重复提交
VerifyCSRFToken verifyAnnotation = method.getAnnotation(VerifyCSRFToken.class);
if (verifyAnnotation != null) {
if (verifyAnnotation.verify()) {
if (StrUtil.isEmpty(xrq)) {
request.getSession().setAttribute("CSRFToken", CSRFTokenUtil.generate(request));
} else {
Map map = new HashMap();
map.put("CSRFToken", CSRFTokenUtil.generate(request));
response.setContentType("application/json;charset=UTF-8");
OutputStream out = response.getOutputStream();
out.write((",'csrf':" + JSONObject.toJSONString(map) + "}").getBytes("UTF-8"));
}
}
}
}
/**
- 处理跨站请求伪造 针对需要登录后才能处理的请求,验证CSRFToken校验
*
- @param request
*/
protected boolean verifyCSRFToken(HttpServletRequest request) {
// 请求中的CSRFToken
String requstCSRFToken = request.getHeader("CSRFToken");
if (StrUtil.isEmpty(requstCSRFToken)) {
return false;
}
String sessionCSRFToken = (String) request.getSession().getAttribute("CSRFToken");
if (StrUtil.isEmpty(sessionCSRFToken)) {
return false;
}
return requstCSRFToken.equals(sessionCSRFToken);
}
}
代码审计技巧
通过项目依赖,查看是否有类似spring security、ESAPI的安全框架,spring security自4.0版本起,默认情况下会启用CSRF保护
一般审计过程中,主要看增、删、改操作中是否包含token、csrfToken等字段信息,以及是否有对referer请求的校验
该类型漏洞在黑盒测试时更容易发现,审计时可结合黑盒测试
越权漏洞
越权访问漏洞,又可以分为平行越权访问漏洞与垂直越权访问漏洞两类。
平行越权访问漏洞,指的是权限平级的两个用户之间的越权访问。比如,一个正常的用户A通常只能够对自己的一些信息进行增删改查,但是由于程序员的一时疏忽未对信息进行增删改查的时候进行一个判断,判断所需要操作的信息是否属于对应的用户,因此,导致用户A可以操作其他人的信息。
垂直越权访问漏洞,指的是权限不等的两个用户之间的越权访问。一般都是,低权限的用户可以直接访问高权限的用户的信息。比如,在论坛中,你是一个普通用户,有一天,你通过burpsuite抓包修改了自己的用户ID为管理员的用户ID,一不小心,成功登陆了管理员的账号。
平行越权
常见错误代码示例如下:
@RequestMapping("/getUserById")
publicString getUserById(Integer id, Model model) {
User user = userService.getUserById(id);
System.out.println(user.toString());
user.setUsername(HtmlUtils.htmlEscape(user.getUsername()));
user.setJob(HtmlUtils.htmlEscape(user.getJob()));
model.addAttribute("user",user);
return"user";
}
上述代码中,getUserById方法通过请求的id参数查询用户,然后将用户信息进行编码返回,没有对请求的ID与当前用户进行身份绑定,从而造成了越权查看他人信息的漏洞。针对此类型漏洞,修复时一般禁止普通用户查看他人信息,只允许查看当前用户自己的身份信息。在用户登陆时将用户身份放入session中,然后从session中获取当前用户,而不是通过请求中的参数获取当前用户。
通常修复代码如下:
@RequestMapping("/userInfo")
publicString getUserInfo(HttpSession session, Model model) {
try{
User user = (User) session.getAttribute("user");
user.setUsername(HtmlUtils.htmlEscape(user.getUsername()));
user.setJob(HtmlUtils.htmlEscape(user.getJob()));
model.addAttribute("user",user);
return"user";
}catch(Exception e) {
e.printStackTrace();
}
return"index";
}
垂直越权
常见错误代码示例如下:
@RequestMapping("/listUser")
publicString listUser(HttpSession session, Model model) {
User user = (User)session.getAttribute("user");
if(user !=null) {
List userList = userService.listUser();
model.addAttribute("userList", userList);
return"show";
}
return"index";
}
上述代码中,从session中获取了user对象,如果不为空则将所有用户信息返回,而该接口本身是设计用于管理员查看所有用户信息,所以此处即存在垂直越权漏洞,代码中只判断是否成功登陆,并没有判断登陆的用户角色和权限。
修复代码如下:
@RequestMapping("/listUser")
publicString listUser(HttpSession session, Model model) {
User user = (User)session.getAttribute("user");
if(user !=null&& "admin".equals(user.getUsername())) {
List userList = userService.listUser();
model.addAttribute("userList", userList);
return"show";
}
return"index";
}
在判断时,判断用户不为空的同时判断获取的用户名是否为admin用户,或者用户组是否为管理员组。
代码审计技巧
通过项目依赖,查看是否有类似spring security、ESAPI的安全框架,是否有使用@EnableWebSecurity注解启用安全功能
越权漏洞不需要关注特定的函数,只要在处理用户操作请求时查看是否有对当前登陆用户权限做校验从而确定是否存在漏洞