java编译过程：
Java源代码 ——（编译）——> Java字节码 ——（解释器）——> 机器码
Java源代码 ——（编译器 ）——> jvm可执行的Java字节码 ——（jvm解释器） ——> 机器可执行的二进制机器码 ——>程序运行
采用字节码的好处：高效、可移植性高
以下示例为.java文件：
以下是.class文件：
jad
jd-gui
idea自带插件
jar包本质上是将所有class文件、资源文件压缩打成一个包。
Servlet：
类似小程序，处理较复杂的服务端业务逻辑
含有HttpServlet类，可进行重写
jsp：
会被编译成一个java类文件，如index.jsp在Tomcat中Jasper编译后会生成index_jsp.java和index_jsp.class两个文件。是特殊的servlet。
使用idea，全局搜索command+shift+f（或者a）
find ~/cms/ -type f -name "*.class" |xargs grep -E "Controller|@RestController|RepositoryRestController"find ~/cms/ -type f -name "*.class" |xargs grep -E "RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping|RepositoryRestResource"审计时，得先看是否含有全局过滤器。切勿看到Servlet、JSP中的漏洞点就妄下定论，Servlet前面很有可能存在一个全局安全过滤的Filter。当然每种框架的写法也有差别。个人认为Filter主要是用在
web.xml全局过滤
<filter>
<filter-name>YytSecurityUrlFilter</filter-name>
<filter-class>com.yytcloud.core.spring.pub.filter.YytSecurityUrlFilter</filter-class>
<async-supported>true</async-supported>
<init-param>
<param-name>sqlInjIgnoreUrls</param-name>
<param-value>.*/itf/.*</param-value>
</init-param>
<init-param>
<param-name>ignoreXSSUrls</param-name>
<param-value>.*/itf/.*</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>YytSecurityUrlFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
jar包
首先添加一个 jar 包:commons-lang-2.5.jar ，然后在后台调用这些函数:
StringEscapeUtils.escapeHtml(string);
StringEscapeUtils.escapeJavaScript(string);
StringEscapeUtils.escapeSql(string);
转义
String string = HtmlUtils.htmlEscape(userinput); //转义
String s2 = HtmlUtils.htmlUnescape(string); //转成原来的
分为业务安全问题、代码实现和服务架构安全问题
代码实现，查看对应代码与全局过滤器：
文件读写(文件上传、文件下载)、文件遍历、文件删除、文件重命名等漏洞业务安全，主要理解该系统的逻辑：
未采用验证码或验证码未做安全刷新(未刷新Session中验证码的值)导致的撞库、密码爆破漏洞。未限制验证码失败次数、验证码有效期、验证码长度过短导致的验证码爆破问题。ORM框架更新操作时因处理不当导致可以更新用户表任意字段(如:用户注册、用户个人资料修改时可以直接创建管理员账号或其他越权修改操作)。ORM框架查询数据时因处理不当导致可以接收任何参数导致的越权查询、敏感信息查询等安全问题。Token机制导致存在CSRF漏洞。越权问题)。ID自增、ID可预测并且云端未验证参数有效性导致的越权访问、信息泄漏问题(如:任意用户订单越权访问)。条件竞争问题，某些关键业务(如:用户转账)不支持并发、分布式部署时不支持锁的操作等。未限制请求频率，导致短信、邮件、电话、私信等信息轰炸。Cookie中直接存储用户密码等重要信息，跟踪cookie中的变量最终到了哪。123456。DWR框架开发时前后端不分漏洞(如:DWR直接调用数据库信息把用户登陆逻辑直接放到了前端来做)。直接拼接，未进行过滤
将request.getParameter("")直接放在SQL语句。
全局搜索查看：String sql等。
预编译使用有误
在使用占位符后未进行setObject或者setInt或者setString。
有些会使用SQLparameter函数，参数化查询SQL，能有效避免SQL注入。
使用setProperties函数。
占位符这种在渗透中出现的情况是：当输入1‘ or ‘1‘=‘1，不会有什么回显。
因为这个引号已经无法起到闭合作用了，只相当于是一个字符，由于对特殊符号的转义。
如图所知，在setString那个函数那里对引号等一些特殊符号做了转义。
// 执行查询
System.out.println(" 实例化Statement对象...");
PreparedStatement st=conn.prepareStatement("select * from " +
"springmysql1 where name=?");
st.setString(1,request.getParameter("name"));
ResultSet rs=st.executeQuery();
%和_
没有手动过滤%。预编译是不能处理这个符号的， 所以需要手动过滤，否则会造成慢查询，造成 dos。
Order by、from等无法预编译
如以下示例，需要手动过滤，否则存在sql注入。
String sql = "Select * from news where title =?" + "order by ‘" + time + "‘ asc"
Mybatis 框架
使用注解或者xml将java对象与数据库sql操作对应。
在注解中或者 Mybatis 相关的配置文件中搜索 $ 。然后查看相关 sql 语句上下文环境。
mybatis简单示例
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
目录结构
java文件
? 配置文件
各文件功能(左下角是我的水印哈哈哈)
config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatistest"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.UserMapper">
<select id="getUser" resultType="org.User1">
select * from user where name=#{name}
</select>
</mapper>
UserMapper.java
package org;
public interface UserMapper{
public User1 getUser(String name);
}
MybatisUtil.java
package org;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.Reader;
public class MybatisUtil{
public static SqlSessionFactory sessionFactory;
static{
try{
Reader reader = Resources.getResourceAsReader("config.xml");
sessionFactory = new SqlSessionFactoryBuilder().build(reader);
}
catch (Exception e){
System.out.println(e);
}
}
public static SqlSession getSession(){
return sessionFactory.openSession();
}
}
User1.java
package org;
import lombok.Data;
@Data
public class User1 {
String name;
int age;
}
test.java
package org;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
import org.junit.Test;
public class test {
@Test
public void test1() {
SqlSession session=MybatisUtil.getSession();
UserMapper userMapper=session.getMapper(UserMapper.class);
User1 user1=userMapper.getUser("wy");
System.out.println(user1.getAge());
}
}
在UserMapper.xml使用#{}的结果
在UserMapper.xml使用${}的结果
使用该符号需要手动写上引号拼接，不然会报错，User1 user1=userMapper.getUser("‘"+"wy‘ or ‘1‘=‘1"+"‘");
容易触发sql注入的条件与修复
like ‘%${xxx}%‘，修复自然是将xxx拎出来，比如使用concat函数。in(${xxx})或者order by ${xxx}。修复是用户自行过滤。:=和和此处的${ids}可防止SQL注入
@Arguments("id")
@Sql("select count(1) from cgform_head where physice_id=:id ")
public int getByphysiceId(String id);
@Arguments("ids")
@Sql("select count(1) as hasPeizhi,physice_id id from cgform_head where 1=1 and physice_id in (${ids}) group by physice_id")
public List<Map<String, Object>> getPeizhiCountByIds(String ids);
像字符型SQL语句的渗透利用在现实中无非三种，可能还需试一下时间盲注等等，视情况而定：
简单描述：
使用el表达式且el表达式可控。如CVE-2018-1260就是spring-security-oauth2的一个SPel注入导致的RCE。
示例：
String el="T(java.lang.Runtime).getRuntime().exec(\"open /tmp\")";
ExpressionParser PARSER = new SpelExpressionParser();
Expression exp = PARSER.parseExpression(el);
System.out.println(exp.getValue());
在getValue那里执行命令，调用栈如下
审计：
查看使用SpelExpressionParser的地方有没有用户可控的。
示例
@RequestMapping("/xss")
public ModelAndView xss(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
String name = request.getParameter("name");
ModelAndView mav = new ModelAndView("mmc");
mav.getModel().put("uname", name);
return mav;
}
如果想要返回json格式，将mmc替换为new MappingJackson2JsonView()。
代码中提供了从其他服务器应用获取数据的功能但没有对目标地址做过滤与限制。比如从指定URL链接获取图片、下载等。主要可能存在于在线文档编辑器之类。
示例
String url = request.getParameter("picurl");
StringBuffer response = new StringBuffer();
URL pic = new URL(url);
HttpURLConnection con = (HttpURLConnection) pic.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("User-Agent", "Mozilla/5.0");
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
return response.toString();
审计
支持的协议
常用的函数
HttpClient.execute
HttpClient.executeMethod
HttpURLConnection.connect
HttpURLConnection.getInputStream
URL.openStream
修复
简单描述：
跨站请求伪造是一种使已登录用户在不知情的情况下执行某种动作的攻击。因为攻击者看不到伪造请求的响应结果，所以CSRF攻击主要用来执行动作，而非窃取用户数据。当受害者是一个普通用户时，CSRF可以实现在其不知情的情况下转移用户资金、发送邮件等操作；但是如果受害者是一个具有管理员权限的用户时CSRF则可能威胁到整个Web系统的安全。
审计：
一些增删改查方法，是否进行Referer头检验、token检验 无法构造的随机数参数、验证码密码。
搜索session["token"]
修护：
Referer头检验、token检验。
简单描述：
当允许引用外部实体且存在输入点时，恶意攻击者即可构造恶意内容访问服务器资源,如读取 passwd 文件
https://www.cnblogs.com/r00tuser/p/7255939.html
示例：
@RequestMapping("/xxetest")
public String xxetest(HttpServletRequest request) throws DocumentException {
String xmldata = request.getParameter("data");
SAXReader sax=new SAXReader();
Document document=sax.read(new ByteArrayInputStream(xmldata.getBytes()));
Element root= ((org.dom4j.Document) document).getRootElement();
List rowList = root.selectNodes("//msg");
Iterator<?> iter1 = rowList.iterator();
if (iter1.hasNext()) {
Element beanNode = (Element) iter1.next();
return beanNode.getTextTrim();
}
return "error";
}
root.selectNodes("//msg")获取根目录下的所有<msg>标签</msg>
利用：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE replace [
<!ENTITY test SYSTEM "file:///tmp/flag">]>
<msg>&test;</msg>
渗透的话可以结合burpsuite的插件：collaborator https://blog.csdn.net/fageweiketang/article/details/89073662
审计：
修护：
saxReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
saxReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
saxReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
SAXBuilder builder = new SAXBuilder();
builder.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
builder.setFeature("http://xml.org/sax/features/external-general-entities", false);
builder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
Document doc = builder.build(new File(fileName));
SAXTransformerFactory sf = SAXTransformerFactory.newInstance(); sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
sf.newXMLFilter(Source);
Note: Use of the following XMLConstants requires JAXP 1.5, which was added to Java in 7u40 and Java 8:
javax.xml.XMLConstants.ACCESS_EXTERNAL_DTD
javax.xml.XMLConstants.ACCESS_EXTERNAL_SCHEMA javax.xml.XMLConstants.ACCESS_EXTERNAL_STYLESHEET
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema"); factory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); factory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
Schema schema = factory.newSchema(Source);
xmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false); // This disables DTDs entirely for that factory
xmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false); // disable external entities
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); // This may not be strictly required as DTDs shouldn‘t be allowed at all, per previous line.
reader.setFeature("http://xml.org/sax/features/external-general-entities", false);
reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
DocumentBuilderFactory df = DocumentBuilderFactory.newInstance(); df.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
DocumentBuilder builder = df.newDocumentBuilder();
String result = new XPathExpression().evaluate( builder.parse(new ByteArrayInputStream(xml.getBytes())) );
TransformerFactory tf = TransformerFactory.newInstance();
tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = factory.newSchema();
Validator validator = schema.newValidator();
validator.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); validator.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setFeature("http://xml.org/sax/features/external-general-entities", false); spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false); spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Source xmlSource = new SAXSource(spf.newSAXParser().getXMLReader(), new InputSource(new StringReader(xml)));
JAXBContext jc = JAXBContext.newInstance(Object.class);
Unmarshaller um = jc.createUnmarshaller();
um.unmarshal(xmlSource);
简单描述：
一个用户，如果他被允许输入结构化的XML片段，则他可以在 XML 的数据域中注入 XML 标签来改写目标 XML 文档的结构与内容。
示例：
private void createXMLStream(BufferedOutputStream outStream, User user) throws IOException
{
String xmlString;
xmlString = "<user><role>operator</role><id>" + user.getUserId()
+"</id><description>" + user.getDescription() +
"</description></user>";
outStream.write(xmlString.getBytes());
outStream.flush();
}
输入以下恶意代码
hhh</id><role>administrator</role><id>hhh
由于 SAX 解析器(org.xml.sax and javax.xml.parsers.SAXParser)在解释 XML 文档时会将第二个role 域的值覆盖前一个 role 域的值，因此导致此用户角色由操作员提升为了管理员。
审计方法：
全局搜索如下字符串
在项目中搜索. Xsd 文件
修护：
字母、数字、下划线。private void createXMLStream(BufferedOutputStream outStream, User user) throws IOException
{
if (!Pattern.matches("[_a-bA-B0-9]+", user.getUserId()))
{
...
}
if (!Pattern.matches("[_a-bA-B0-9]+", user.getDescription()))
{
...
}
String xmlString = "<user><id>" + user.getUserId()
\+ "</id><role>operator</role><description>"
\+ user.getDescription() + "</description></user>";
outStream.write(xmlString.getBytes());
outStream.flush();
}
使用 dom4j来构建 XML。
dom4j 是一个良好定义的、开源的 XML 工具库。Dom4j将会对文本数据域进行 XML 编码，从而使得 XML 的原始结构和格式免受破坏。
public static void buidlXML(FileWriter writer, User user) throws IOException
{
Document userDoc = DocumentHelper.createDocument();
Element userElem = userDoc.addElement("user");
Element idElem = userElem.addElement("id");
idElem.setText(user.getUserId());
Element roleElem = userElem.addElement("role");
roleElem.setText("operator");
Element descrElem = userElem.addElement("description");
descrElem.setText(user.getDescription());
XMLWriter output = null;
try{
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
output = new XMLWriter(writer, format);
output.write(userDoc);
output.flush();
}
finally{
try{
output.close();
}
catch (Exception e){}
}
}
水平越权和垂直越权。
审计：
在每个request.getParameter("userid");之后查看是否有检验当前用户与要进行增删改查的用户。
修护：
获取当前登陆用户并校验该用户是否具有当前操作权限，并校验请求操作数据是否属于当前登陆用户，当前登陆用户标识不能从用户可控的请求参数中获取。
简单描述：
在部分接口，没有进行验证码等防护，导致可以无限制重发接口，结果是浪费了系统资源的才算。比如一直发短信验证码，但是可以不断查询就不算批量请求漏洞。批量请求与csrf的修护建议类似，但由于使用场景不同，因此漏洞不同。
修护：
简单描述：
执行的命令用户可控。
示例：
String cmd=request.getParameter("cmd");
Runtime.getRuntime.exec(cmd);
审计：
查找是否有使用如下方法，且其中的内容用户可控。
Runtime.exec
ProcessBuilder.start
GroovyShell.evaluate
简单描述：
Java 程序使用 ObjectInputStream 对象的readObject方法将反序列化数据转换为 java 对象。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码。
示例：
//读取输入流,并转换对象
InputStream in=request.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in); //恢复对象
ois.readObject();
ois.close();
审计：
java 序列化的数据一般会以标记(ac ed 00 05)开头，base64 编码后的特征为rO0AB。
找出反序列化函数调用点：
RMI:是 Java 的一组拥护开发分布式应用程序的 API，实现了不同操作系统之间程序的方法调用。RMI 的传输 100%基于反序列化，Java RMI 的默认端口是 1099 端口。
修护：
白名单。只允许某些类被反序列化。
以下例子通过重写ObjectInputSream中的resolveClass方法，读取需要反序列化的类名与SerialObject.class对比，判断是否合法。SerialKiller就是利用这种原理而写的jar包。
/**只允许反序列化 SerialObject class */
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(SerialObject.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt",
desc.getName());
}
return super.resolveClass(desc);
}
}
SerialKiller简单用法
ObjectInputStream ois = new SerialKiller(is, "/etc/serialkiller.conf");
String msg = (String) ois.readObject();
Apache Commons IO Serialization 包中的ValidatingObjectInputStream 类的accept方法来实现反序列化类白/黑名单控制
Object obj;
ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
// Use ValidatingObjectInputStream instead of InputStream
ValidatingObjectInputStream ois = new ValidatingObjectInputStream(bais);
//只允许反序列化SerialObject class
ois.accept(SerialObject.class);
obj = ois.readObject();
简单描述：
没懂所以不想写
审计：
手工搜索以下文本
修护：
简单描述：
将敏感数据连着实例方法一起序列化，导致敏感数据泄漏。
示例：
假设x和y是敏感数据，序列化后面临坐标泄漏危险
public class GPSLocation implements Serializable
{
private double x; // sensitive field
private double y; // sensitive field
private String id;// non-sensitive field
// other content
}
public class Coordinates
{
public static void main(String[] args)
{
FileOutputStream fout = null;
try{
GPSLocation p = new GPSLocation(5, 2, "northeast");
fout = new FileOutputStream("location.ser");
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(p);
oout.close();
}
catch (Throwable t){
// Forward to handler
}
finally{
if (fout != null){
try{
fout.close();
}
catch (IOException x){
// handle error
}
}
}
}
}
审计：
对于已经被确定为敏感的数据搜索示例一中相关的关键字。
或者查看进行序列化的类，是否含有敏感数据。
修护：
private transient double x; // transient field will not be serialized
private transient double y; // transient field will not be serialized
serialPersistentFields，那么其余将不会被序列化public class GPSLocation implements Serializable
{
private double x;
private double y;
private String id;
// sensitive fields x and y are not content in serialPersistentFields
private static final ObjectStreamField[] serialPersistentFields = {new ObjectStreamField("id", String.class)};// other content
}
简单描述：
没懂
审计：
人工查找 implements Serializable 的所有内部类
修护：
class \${InnerSer} {}
去除内部类的序列化。
static class ?\${InnerSer} implements Serializable {}把内部类声明为静态从而被序列化。但是要注意遵循示例三中的敏感信息问题
简单描述：
攻击者利用../可以上传至任意指定目录。
服务端使用getAbsolutePath()的话无法检测出攻击者真正上传的文件路径，因此即使做了过滤也将可被绕过。
示例：
当前目录E:\workspace\myTestPathPrj(windows系统)
public static void testPath() throws Exception{
File file = new File("..\\src\\ testPath.txt");
System.out.println(file.getAbsolutePath());
System.out.println(file.getCanonicalPath());
}
file.getAbsolutePath()打印出E:\workspace\myTestPathPrj\..\src\testpath.txt
file.getCanonicalPath()打印出E:\workspace\src\testPath.txt
审计：
查找permission Java.io.FilePermission字样和 grant 字样，看是否已经做出防御。
查找getAbsolutePath()和getPath()，找到后看有没有用户输入的。
简单描述：
两个危害：一个是提取出的文件标准路径落在解压的目标目录之外，另一个是提取出的文件消耗过多的系统资源。
示例：
解压后的文件名未作过滤（直接entry.getName()）；
未对上传的压缩包大小作限制（zis.read后直接dest.write）
static final int BUFFER = 512;
// ...
public final void unzip(String fileName) throws java.io.IOException
{
FileInputStream fis = new FileInputStream(fileName);
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null)
{
System.out.println("Extracting: " + entry);
int count;
byte data[] = new byte[BUFFER];
// Write the files to the disk
FileOutputStream fos = new FileOutputStream(entry.getName());
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
while ((count = zis.read(data, 0, BUFFER)) != -1)
{
dest.write(data, 0, count);
}
dest.flush();
dest.close();
zis.closeEntry();
}
zis.close();
}
解压后的文件名未作过滤；
使用getSize()函数不能准确判断压缩包大小，攻击者可以修改压缩包的16进制编码进行绕过。恶意攻击者可以伪造 ZIP 文件中用来描述解压条目大小的字段，因此，getSize()方法的返回值是不可靠的。
public static final int BUFFER = 512;
public static final int TOOBIG = 0x6400000; // 100MB
// ...
public final void unzip(String filename) throws java.io.IOException
{
FileInputStream fis = new FileInputStream(filename);
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
ZipEntry entry;
try{
while ((entry = zis.getNextEntry()) != null)
{
System.out.println("Extracting: " + entry);
int count;
byte data[] = new byte[BUFFER];
// Write the files to the disk, but only if the file is not insanely
if (entry.getSize() > TOOBIG)
{
throw new IllegalStateException("File to be unzipped is huge.");
}
if (entry.getSize() == -1)
{
throw new IllegalStateException("File to be unzipped might be huge.");
}
FileOutputStream fos = new FileOutputStream(entry.getName());
BufferedOutputStream dest = new BufferedOutputStream(fos,BUFFER);
while ((count = zis.read(data, 0, BUFFER)) != -1)
{
dest.write(data, 0, count);
}
dest.flush();
dest.close();
zis.closeEntry();
}
}
finally{
zis.close();
}
}
审计：
搜索以下函数，看是否有使用到：
如果出现 getSize 基本上就需要特别注意了。
修护：
getCanonicalPath()，过滤。File f = new File(intendedDir, entryName);
String canonicalPath = f.getCanonicalPath();
File iD = new File(intendedDir);
String canonicalID = iD.getCanonicalPath();
if (canonicalPath.startsWith(canonicalID))
{
return canonicalPath;
}
else
{
...
}
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
while (total + BUFFER <= TOOBIG && (count = zis.read(data, 0, BUFFER)) != -1)
JDK<1.7.40的版本存在空字节问题。
简单描述：
可读取用户输入的文件路径并回显在响应中。
审计：
快速发现这类漏洞的方式其实也是非常简单的，在IDEA中的项目中重点搜下如下文件读取的类。
JDK原始的java.io.FileInputStream类
JDK原始的java.io.RandomAccessFile类
Apache Commons IO提供的org.apache.commons.io.FileUtils类
JDK1.7新增的基于NIO非阻塞异步读取文件的java.nio.channels.AsynchronousFileChannel类
JDK1.7新增的基于NIO读取文件的java.nio.file.Files类
常用方法如:Files.readAllBytes、Files.readAllLines
如果仍没有什么发现可以搜索一下FileUtil，很有可能用户会封装文件操作的工具类。（参考)
简单描述：
接口从host头或者参数中取值，直接跳转到用户自定义的url，导致url重定向。
示例：
访问不存在的资源，将host改成自定义url，页面302跳转，跳转地址为host头中的自定义url。
@RequestMapping("/urltest")
@ResponseBody
public String urltest(HttpServletRequest request,HttpServletResponse response) throws ServletException,
IOException {
String site = request.getParameter("url");
if(!site.isEmpty()){
response.sendRedirect(site);
}
return response.toString();
}
审计：
查找sendRedirect，跳转的url是否用户可控，如果可控是否有进行过滤判断。
特别是在删掉某个资源的斜杠，有可能就进行了302跳转，该处时常出现url重定向漏洞。
简单描述：
将HTTP请求参数绑定到程序代码变量或对象中。逻辑型漏洞。
@ModelAttribute注解
客户端传递过来的参数按名称注入到指定对象中，并且会将这个对象自动加入ModelMap中，便于View层使用@RequestMapping(value = "/home", method = RequestMethod.GET)
public String home(@ModelAttribute User user, Model model) {
if (showSecret){
model.addAttribute("firstSecret", firstSecret);
}
return "home";
}
前端jsp中可使用${user.name}访问对象user中的name成员。注意这时候这个User类一定要有没有参数的构造函数。
@SessionAttributes注解
setComplete()方法，这个对象就会一直保留在 Session 中示例：
在/resetQuestion接口，从客户端传入user的成员answer=hhd，因为代码@ModelAttribute User user，answer将会注入到user对象，并自动加入ModelMap中。
在/reset接口，因为代码@SessionAttributes("user")，将user对象从ModelMap中读出并放入session中，因此user中的answer=hhd也加入了session中。那么只需要输入问题的答案为hhd则与session中的hhd匹配，因此可绕过。
@Controller
@SessionAttributes("user")
public class ResetPasswordController {
private UserService userService;
...
@RequestMapping(value = "/reset", method = RequestMethod.POST)
public String resetHandler(@RequestParam String username, Model model) {
User user = userService.findByName(username);
if (user == null) {
return "reset";
}
model.addAttribute("user", user);
return "redirect: resetQuestion";
}
@RequestMapping(value = "/resetQuestion", method = RequestMethod.GET)
public String resetViewQuestionHandler(@ModelAttribute User user) {
logger.info("Welcome resetQuestion ! " + user);
return "resetQuestion";
}
修护：
Spring MVC中可以使用@InitBinder注解，通过WebDataBinder的方法setAllowedFields、setDisallowedFields设置允许或不允许绑定的参数。
Web Service是一种基于SOAP协议实现的跨语言Web服务调用。配置web.xml，配置server-config.wsdd文件注册Web Service服务类和方法。
访问Web Service的FileService服务加上?wsdl参数可以看到FileService提供的服务方法和具体的参数信息。
一般扫描目录时可扫出，后带?wsdl的是接口总的说明文档
此类漏洞可使用burpsuite的wsdl插件，直接进行解析生成不同接口的request，再发送到repeater
接口可能是查询，可能是添加等等操作
根据报错信息，可能存在注入点
比如struts2、不安全的编辑控件、fastjson等等。
原文：https://www.cnblogs.com/nongchaoer/p/13324114.html