一个字母大写后能变长,这事听着反直觉,但 Ruby 官方 2026 年 11 月 18 日的安全公告里,CVE-2026-132825 正是这么来的:单字节编码下的 ß 大写要写成两个字节 SS,缓冲区却只按一个字节预留,凑够 21 个就正好越界一个字节。这个洞被叫作 Ruby2Shell,公告同时说明 UTF-8 字符串不走这条路。公告列出的受影响方法一堆:upcase、swapcase、downcase(:fold)、casecmp? 以及对应的 bang 变体和 Symbol 版本,全都是日常代码里随手就调的东西。本文不碰利用链,只用 Python 标准库把"一个字符怎么变两个、账本怎么算漏、怎么提前拦住"这三件事在本地跑一遍,代码复制即可运行。
环境准备
本机 Python 3.13.14,只用标准库,不需要装任何包:
bash
python -c "import sys; print(sys.version)"
一个字符怎么变成两个
Unicode 里大小写转换不是一比一映射。德语尖 s(ß)、拉丁连字(ffi、fi)、土耳其 İ 都有"一个变多个"的行为,Python 的 str.upper / str.lower / str.casefold 直接能看到长度变化:
python
samples = ["ß", "İ", "ffi", "ẞ", "ı", "fi", "a"]
for ch in samples:
up, lo, cf = ch.upper(), ch.lower(), ch.casefold()
print(f"{ch!r:8} up={up!r:10} {len(ch)}->{len(up)} "
f"lo={lo!r:10} {len(ch)}->{len(lo)} cf={cf!r:10} {len(ch)}->{len(cf)}")
实测输出(节选):
text
'ß' up='SS' 1->2 lo='ß' 1->1 cf='ss' 1->2
'İ' up='İ' 1->1 lo='i̇' 1->2 cf='i̇' 1->2
'ffi' up='FFI' 1->3 lo='ffi' 1->1 cf='ffi' 1->3
'ẞ' up='ẞ' 1->1 lo='ß' 1->1 cf='ss' 1->2
'fi' up='FI' 1->2 lo='fi' 1->1 cf='fi' 1->2
ß 的 upper 和 casefold 都是 1→2,连字 ffi 更是 1→3。转换前按字符数算长度、转换后按字符数取值,从这里就开始错位了。
为什么单字节编码才出事
关键点在"字节"而不是"字符"。同一个 ß,在 UTF-8 里是两个字节,在 ISO-8859-1 / Windows-1252 里是单个字节 0xDF;而 SS 在两种编码里都是两个字节:
python
for enc in ["utf-8", "latin-1", "cp1252"]:
b = "ß".encode(enc)
print(f"ß @ {enc:8} -> {b!r} len={len(b)}")
print(f"SS @ latin-1 -> {'SS'.encode('latin-1')!r} len={len('SS'.encode('latin-1'))}")
实测输出:
text
ß @ utf-8 -> b'\xc3\x9f' len=2
ß @ latin-1 -> b'\xdf' len=1
ß @ cp1252 -> b'\xdf' len=1
SS @ latin-1 -> b'SS' len=2
UTF-8 下 2 字节变 2 字节,长度没膨胀,所以公告明确说 UTF-8 不受影响。只有在单字节编码里,1 字节的输入要写 2 字节的输出,多出来的那一字节才有地方惹祸。Ruby 官方公告把受影响面列在 ISO-8859 系列和 Windows-1250/1252/1254/1257,这些结构性结论引自该公告,上表的字节数则是本机实测。
这里有个容易被忽略的前提:攻击面不在"你用不用 UTF-8",而在"有没有把外来字节流当成单字节编码再去做大小写转换"。公告点名的场景是老编码导入、CSV 处理、邮件和各种旧数据库桥接------这些地方常把输入强制打上 Latin-1 之类的标签。所以哪怕主站是 UTF-8,只要链路里有一段把字符串 force_encoding 成单字节再 upcase,这条路径就还在。
算清那 21 个字节的账
按公开披露,Ruby 给输出缓冲区预留的是"输入长度 + 20 字节",每处理一个 ß 就多占一个额外字节。把这个账本写成纯计数模型(不碰内存,只算数):
python
def budget(n, spare=20):
buf = n * 1 + spare # 单字节编码:每个 ß 输入占 1 字节
need = n * 2 # 每个 ß 大写 -> "SS" 写 2 字节
pos = 0
overflow_at = None
for i in range(n):
pos += 2
if pos > buf and overflow_at is None:
overflow_at = i + 1
return buf, need, pos - buf, overflow_at
for n in [19, 20, 21, 22, 30]:
buf, need, over, at = budget(n)
print(f"n={n:3} buf={buf:3} need={need:3} 溢出={over:2} 首次溢出第={at} 个")
实测输出:
text
n= 19 buf= 39 need= 38 溢出=-1 首次溢出第=None 个
n= 20 buf= 40 need= 40 溢出= 0 首次溢出第=None 个
n= 21 buf= 41 need= 42 溢出= 1 首次溢出第=21 个
n= 22 buf= 42 need= 44 溢出= 2 首次溢出第=22 个
n= 30 buf= 50 need= 60 溢出=10 首次溢出第=26 个
20 个刚好填满预留,第 21 个开始越界,一个不多一个不少------这跟官方披露的"21 个 ß 溢出恰好一个字节"完全对上。我的理解是:问题不在 ß 本身,而在"按输入长度预留、按最坏 2 倍写入"这个假设没立住。
正确的检查该怎么写
写 2 字节之前,得先确认剩余空间至少是 2,而不是 1。把检查条件改掉,同样的输入就变成"到点停下或扩容":
python
def safe_budget(n, spare=20):
buf = n + spare
pos = 0
writes = 0
for i in range(n):
if buf - pos < 2: # 正确:写 2 字节前检查 2 字节余量
return buf, writes, "STOP/扩容", i + 1
pos += 2
writes += 1
return buf, writes, "OK", None
for n in [20, 21, 30]:
print(n, safe_budget(n))
实测输出:
text
20 (40, 20, 'OK', None)
21 (41, 20, 'STOP/扩容', 21)
30 (50, 25, 'STOP/扩容', 26)
n=21 时写完 20 个就停了,不会去碰那个越界位置。真实运行时这里的"停"对应的是扩容或拒绝,Ruby 的修复提交采取的是"写入扩展字符前确保有两个字节空间"。
还有两个容易漏的坑
一个是往返不等。ß 大写是 SS,SS 再小写是 ss,回不到 ß:
python
s = "ß"
print(s.upper(), s.upper().lower(), s.upper().lower() == s)
实测输出:
text
SS ss False
凡是把"大写再小写"当作规范化、拿结果做唯一键或比较的,遇到 ß 就会分叉。
另一个是膨胀不止 2 倍。上面算账用的是 ß 的 2 倍模型,但 Unicode 里还有更狠的。在本机扫一遍基本多文种平面前段(0x0000 到 0x2FFF),upper 会膨胀的字符有 90 个,casefold 有 92 个;继续扫到全部码位,单字符膨胀最大是 3 倍:
python
ch = "ΐ"
print(f"{ch!r} upper={ch.upper()!r} {len(ch)}->{len(ch.upper())}")
print(f"{ch!r} casefold={ch.casefold()!r} {len(ch)}->{len(ch.casefold())}")
实测输出:
text
'ΐ' upper='Ϊ́' 1->3
'ΐ' casefold='ΐ' 1->3
写个能直接用的防御函数
结论落到代码上:单字节编码场景里,转换前先按目标编码算出实际字节数,超了就拒绝,别让底层去赌缓冲区够不够:
python
def converted_upper_len(s: str) -> int:
# 逐字符求和,得到 upper 结果长度的精确上界,不依赖底层实现
return sum(len(ch.upper()) for ch in s)
def safe_upper(s: str, max_bytes: int, enc: str = "latin-1") -> str | None:
out = s.upper()
try:
nbytes = len(out.encode(enc))
except UnicodeEncodeError:
return None
return out if nbytes <= max_bytes else None
for text in ["SSSS", "ß" * 20, "ß" * 21, "İ" * 5]:
print(f"len={len(text):3} 上界={converted_upper_len(text):3} "
f"safe_upper(40)={safe_upper(text, 40)}")
实测输出:
text
len= 4 上界= 4 safe_upper(40)=SSSS
len= 20 上界= 40 safe_upper(40)=SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
len= 21 上界= 42 safe_upper(40)=None
len= 5 上界= 5 safe_upper(40)=None
注意 İ 那一行:字符数只有 5、长度上界也是 5,但它在 latin-1 里根本无法编码,safe_upper 直接返回 None。只看字符数会漏掉它,编码层的检查不能省。
小结
大小写转换看着是字符串操作,落到字节上就是一次可能变长的写入。能记住一条就够:在单字节编码里做大小写转换之前,先按目标编码量一遍实际字节数,超预算就拒绝或扩容。UTF-8 用户这次可以松口气,但别把"我用的是 UTF-8"当成永远不用检查的理由。