feat: support open-liberty javaee

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty18ContainerTest.java

@@ -0,0 +1,97 @@
+package com.reajason.javaweb.integration.memshell.websphere;
+
+import com.reajason.javaweb.Server;
+import com.reajason.javaweb.integration.ShellAssertion;
+import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+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.time.Duration;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty18ContainerTest {
+    public static final String imageName = "open-liberty:18.0.0.4-webProfile8";
+    static Network network = Network.newNetwork();
+    @Container
+    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(neoGeorgDockerfile))
+            .withNetwork(network);
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/app.war", BindMode.READ_WRITE)
+            .withCopyToContainer(jattachFile, "/jattach")
+            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
+            .withNetwork(network)
+            .withNetworkAliases("app")
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    static Stream<Arguments> casesProvider() {
+        String server = Server.WebSphere;
+        List<String> supportedShellTypes = List.of(
+                ShellType.SERVLET,
+                ShellType.FILTER,
+                ShellType.LISTENER,
+                ShellType.WAS_AGENT_FILTER_MANAGER
+        );
+        List<Packers> testPackers = List.of(Packers.JSP);
+        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        String logs = container.getLogs();
+        log.info(logs);
+        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
+    }
+
+    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
+    @MethodSource("casesProvider")
+    void test(String imageName, String shellType, String shellTool, Packers packer) {
+        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
+    }
+
+    public static String getUrl(GenericContainer<?> container) {
+        String host = container.getHost();
+        int port = container.getMappedPort(9080);
+        String url = "http://" + host + ":" + port + "/app";
+        log.info("container started, app url is : {}", url);
+        return url;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {ShellType.SERVLET,
+            ShellType.FILTER,
+            ShellType.LISTENER,})
+    void testProbeInject(String shellType) {
+        String url = getUrl(container);
+        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty20ContainerTest.java

@@ -0,0 +1,97 @@
+package com.reajason.javaweb.integration.memshell.websphere;
+
+import com.reajason.javaweb.Server;
+import com.reajason.javaweb.integration.ShellAssertion;
+import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+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.time.Duration;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty20ContainerTest {
+    public static final String imageName = "open-liberty:20.0.0.12-full-java8-openj9";
+    static Network network = Network.newNetwork();
+    @Container
+    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(neoGeorgDockerfile))
+            .withNetwork(network);
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/app.war", BindMode.READ_WRITE)
+            .withCopyToContainer(jattachFile, "/jattach")
+            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
+            .withNetwork(network)
+            .withNetworkAliases("app")
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    static Stream<Arguments> casesProvider() {
+        String server = Server.WebSphere;
+        List<String> supportedShellTypes = List.of(
+                ShellType.SERVLET,
+                ShellType.FILTER,
+                ShellType.LISTENER,
+                ShellType.WAS_AGENT_FILTER_MANAGER
+        );
+        List<Packers> testPackers = List.of(Packers.JSP);
+        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        String logs = container.getLogs();
+        log.info(logs);
+        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
+    }
+
+    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
+    @MethodSource("casesProvider")
+    void test(String imageName, String shellType, String shellTool, Packers packer) {
+        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
+    }
+
+    public static String getUrl(GenericContainer<?> container) {
+        String host = container.getHost();
+        int port = container.getMappedPort(9080);
+        String url = "http://" + host + ":" + port + "/app";
+        log.info("container started, app url is : {}", url);
+        return url;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {ShellType.SERVLET,
+            ShellType.FILTER,
+            ShellType.LISTENER,})
+    void testProbeInject(String shellType) {
+        String url = getUrl(container);
+        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty22ContainerTest.java

@@ -0,0 +1,97 @@
+package com.reajason.javaweb.integration.memshell.websphere;
+
+import com.reajason.javaweb.Server;
+import com.reajason.javaweb.integration.ShellAssertion;
+import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+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.time.Duration;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty22ContainerTest {
+    public static final String imageName = "open-liberty:22.0.0.12-full-java11-openj9";
+    static Network network = Network.newNetwork();
+    @Container
+    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(neoGeorgDockerfile))
+            .withNetwork(network);
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/app.war", BindMode.READ_WRITE)
+            .withCopyToContainer(jattachFile, "/jattach")
+            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
+            .withNetwork(network)
+            .withNetworkAliases("app")
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    static Stream<Arguments> casesProvider() {
+        String server = Server.WebSphere;
+        List<String> supportedShellTypes = List.of(
+                ShellType.SERVLET,
+                ShellType.FILTER,
+                ShellType.LISTENER,
+                ShellType.WAS_AGENT_FILTER_MANAGER
+        );
+        List<Packers> testPackers = List.of(Packers.JSP);
+        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        String logs = container.getLogs();
+        log.info(logs);
+        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
+    }
+
+    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
+    @MethodSource("casesProvider")
+    void test(String imageName, String shellType, String shellTool, Packers packer) {
+        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V11, packer, container, python);
+    }
+
+    public static String getUrl(GenericContainer<?> container) {
+        String host = container.getHost();
+        int port = container.getMappedPort(9080);
+        String url = "http://" + host + ":" + port + "/app";
+        log.info("container started, app url is : {}", url);
+        return url;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {ShellType.SERVLET,
+            ShellType.FILTER,
+            ShellType.LISTENER,})
+    void testProbeInject(String shellType) {
+        String url = getUrl(container);
+        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V11);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty25ContainerTest.java

@@ -0,0 +1,97 @@
+package com.reajason.javaweb.integration.memshell.websphere;
+
+import com.reajason.javaweb.Server;
+import com.reajason.javaweb.integration.ShellAssertion;
+import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.testcontainers.containers.BindMode;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+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.time.Duration;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static com.reajason.javaweb.integration.ContainerTool.*;
+import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
+import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty25ContainerTest {
+    public static final String imageName = "open-liberty:25.0.0.12-full-java17-openj9";
+    static Network network = Network.newNetwork();
+    @Container
+    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
+            .withDockerfile(neoGeorgDockerfile))
+            .withNetwork(network);
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/app.war", BindMode.READ_WRITE)
+            .withCopyToContainer(jattachFile, "/jattach")
+            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
+            .withNetwork(network)
+            .withNetworkAliases("app")
+            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .withExposedPorts(9080)
+            .withPrivilegedMode(true);
+
+    static Stream<Arguments> casesProvider() {
+        String server = Server.WebSphere;
+        List<String> supportedShellTypes = List.of(
+                ShellType.SERVLET,
+                ShellType.FILTER,
+                ShellType.LISTENER,
+                ShellType.WAS_AGENT_FILTER_MANAGER
+        );
+        List<Packers> testPackers = List.of(Packers.JSP);
+        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        String logs = container.getLogs();
+        log.info(logs);
+        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
+    }
+
+    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
+    @MethodSource("casesProvider")
+    void test(String imageName, String shellType, String shellTool, Packers packer) {
+        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V17, packer, container, python);
+    }
+
+    public static String getUrl(GenericContainer<?> container) {
+        String host = container.getHost();
+        int port = container.getMappedPort(9080);
+        String url = "http://" + host + ":" + port + "/app";
+        log.info("container started, app url is : {}", url);
+        return url;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {ShellType.SERVLET,
+            ShellType.FILTER,
+            ShellType.LISTENER,})
+    void testProbeInject(String shellType) {
+        String url = getUrl(container);
+        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V17);
+    }
+}

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

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Server;
+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.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.getUrlFromWAS;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty18ContainerTest {
+    public static final String imageName = "open-liberty:18.0.0.4-webProfile8";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/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("JRE|1.8.0_211|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(Server.WebSphere, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+}

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

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Server;
+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.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.getUrlFromWAS;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty20ContainerTest {
+    public static final String imageName = "open-liberty:20.0.0.12-full-java8-openj9";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/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("JRE|1.8.0_292|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(Server.WebSphere, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+}

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

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Server;
+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.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.getUrlFromWAS;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty22ContainerTest {
+    public static final String imageName = "open-liberty:22.0.0.12-full-java11-openj9";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/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("JRE|11.0.19|55", 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(Server.WebSphere, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+}

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

@@ -0,0 +1,81 @@
+package com.reajason.javaweb.integration.probe.websphere;
+
+import com.reajason.javaweb.Server;
+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.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.getUrlFromWAS;
+import static com.reajason.javaweb.integration.ContainerTool.warFile;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/21
+ */
+@Testcontainers
+@Slf4j
+public class OpenLiberty25ContainerTest {
+    public static final String imageName = "open-liberty:25.0.0.12-full-java17-openj9";
+    @Container
+    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
+            .withFileSystemBind(warFile.getFilesystemPath(), "/config/dropins/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("JRE|17.0.17|61", 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(Server.WebSphere, data);
+    }
+
+    @Test
+    @SneakyThrows
+    void testCommandReqHeaderResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseCommandIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+
+    @Test
+    @SneakyThrows
+    void testBytecodeReqParamResponseBody() {
+        String url = getUrlFromWAS(container);
+        ProbeAssertion.responseBytecodeIsOk(url, Server.WebSphere, Opcodes.V1_8);
+    }
+}