CVE-2026-55785 free5GC AUSF 的非常数时间比较与 XRES* 日志泄露
这并非普通的输入校验遗漏,而是两条基本安全规则同时失守:认证材料的比较未采用常数时间实现,认证材料本身又被写入常规日志
0. 核心结论
free5GC AUSF 在 5G-AKA / EAP-AKA' 认证流程中存在两类彼此独立的缺陷:
- CWE-532(敏感信息写入日志):向量生成阶段(
internal/sbi/processor/ue_authentication.go:394)和 5G-AKA 比较前(internal/sbi/processor/ue_authentication.go:578)均以 INFO 级别将期望认证响应值XRES*以可逆编码形式写入应用日志。 - CWE-208 / CWE-385(非常数时间比较):认证响应值通过
strings.EqualFold、bytes.Equal和字符串==比较,没有使用crypto/subtle.ConstantTimeCompare等常数时间原语。
一句话结论:这并非普通的输入校验遗漏,而是两条基本安全规则同时失守:认证材料的比较未采用常数时间实现,认证材料本身又被写入常规日志。已证实的直接影响是认证材料经由日志跨越了信任边界。若日志读取者同时具备相应的 SBI 调用权限或网络路径,便可能利用泄露的 XRES* 提交确认;原因是 AUSF 未对 5G-AKA 认证上下文实施一次性消费。至于这能否在真实部署中演变为跨主体影响,仍取决于 SBI 授权与 UDM 行为;远程定时恢复同样缺乏端到端证据。
1. 范围、版本与证据模型
1.1 版本与对象
属性 | 值 | 证据 |
CVE | CVE-2026-55785 | |
受影响组件 |
| GHSA 公告、Issue #1067 |
受影响版本 |
| GHSA 公告、仓库提交记录 |
修复交付 | 修复提交已包含于 | GitHub PR/Release API 与发布产物交叉核对 |
修复 PR | #63(2026-06-22 合并,作者 wiwi878) | GitHub PR API |
CVSS 3.1 |
| GHSA 公告、NVD API |
CWE | CWE-208 / CWE-385 / CWE-532 | GHSA 公告、NVD API |
漏洞模块 |
|
经 GitHub 提交、PR 和发布产物核验,修复已随 v1.4.5 发布。需要注意的是,GHSA 的 patched versions 字段尚未同步,因此本文仅将 v1.4.5 描述为包含修复的发布版本,而非 GHSA 已确认的修复版本。NVD 2.0 API 亦记录修复版本为 1.4.5;其 CVSS 为 GitHub 提供的 Secondary 评分,并非 NVD 的独立重评。
除非另有标注,源码位置均以脆弱提交 bfc4a100… 为准,并写为 相对路径:行号。在同一段落或表格中,首次出现完整路径后可简写为 文件名:行号;两种写法都明确包含文件名。例如,internal/sbi/processor/ue_authentication.go:394 表示该文件第 394 行。
1.2 审计与测试环境
项 | 值 |
审计源码 |
|
修复源码 |
|
构建镜像 |
|
mock NRF/UDM |
|
编排 |
|
运行时复现/截图环境 | 一次性 Linux 容器(linux/arm64): |
静态分析环境(CodeQL) | macOS (darwin/arm64),CodeQL CLI |
NRF/UDM 均为 mock 实现(
mockcore/main.go),只提供 AUSF 跑通 5G-AKA 所需的最小 SBI 接口,不代表真实 NRF/UDM 的鉴权、限流和状态语义。实验使用下列固定的脱敏认证向量,不涉及真实订户材料。
mock UDM 的实际响应逻辑如下。它只在POST .../security-information/generate-auth-data 时返回 5G_AKA 向量,且对POST .../auth-events 始终返回 201 Created。因此,本文只能对 5G-AKA 做端到端
回归,不能将结果外推至 EAP-AKA':该 mock 不生成 EAP 向量。
case r.Method == http.MethodPost &&
strings.HasSuffix(r.URL.Path, "/security-information/generate-auth-data"):
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"authType": "5G_AKA",
"authenticationVector": map[string]interface{}{
"rand": rand, "xresStar": xresStar, "autn": autn, "kausf": kausf,
},
"supi": supi,
})
case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/auth-events"):
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"authType": "5G_AKA", "success": true,
"servingNetworkName": "5G:mnc070.mcc208.3gppnetwork.org",
})mock UDM 固定返回以下认证向量:
supi = imsi-2089300007487
rand = b8a6c1d2e3f405162738495a6b7c8d9e
xresStar = 0123456789abcdef0123456789abcdef ← 泄露目标
autn = 5449ab1c9c91f9f60000000000000000
kausf = 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff这是脱敏 mock 向量,不代表真实运营商凭据,不触及真实订户或公共网络。
复现所需的 mock 语义、Compose 配置、请求命令、判定条件和清理命令均在第 4 节与第 6.4 节直接给出;不以单独的文件哈希表作为阅读前提。
1.3 本文实际依赖的认证材料与派生关系
以下派生关系均来自脆弱版 ue_authentication.go。
5G-AKA 路径(UeAuthPostRequestProcedure / Auth5gAkaComfirmRequestProcedure):
- 从 UDM 取得认证向量,字段为十六进制字符串:
Rand、Autn、XresStar、Kausf。 HXRES* = SHA256(hexDecode(Rand || XresStar))[16:](internal/sbi/processor/ue_authentication.go:376、internal/sbi/processor/ue_authentication.go:392–393)。HXRES*是由RAND || XRES*派生的期望响应摘要,并通过5gAuthData的 SBI 响应返回给 AMF/SEAF。源码仅能证明它不同于原始XRES*,且会跨越这一 SBI 边界;不能据此笼统认定它是“公开或非机密数据”。UE 经无线/NAS 路径接收的是挑战材料,而非该 SBI 响应对象;本漏洞直接泄露的是原始XRES*。Kseaf = KDF(Kausf, FC_FOR_KSEAF_DERIVATION, P0=servingNetworkName)(internal/sbi/processor/ue_authentication.go:414)。
对应源码同时展示了输入字段、派生过程、上下文保存和返回给调用方的字段:
case models.UdmUeauAuthType__5_G_AKA:
logger.UeAuthLog.Infoln("Use 5G AKA auth method")
putLink += "/5g-aka-confirmation"
// Derive HXRES* from XRES*
concat := authInfoResult.AuthenticationVector.Rand +
authInfoResult.AuthenticationVector.XresStar
hxresStarBytes, err := hex.DecodeString(concat)
if err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "CONCAT_DECODE_PROBLEM",
})
return
}
hxresStarAll := sha256.Sum256(hxresStarBytes)
hxresStar := hex.EncodeToString(hxresStarAll[16:]) // last 128 bits
logger.Auth5gAkaLog.Infof("XresStar = %x\n",
authInfoResult.AuthenticationVector.XresStar)
// Derive Kseaf from Kausf
Kausf := authInfoResult.AuthenticationVector.Kausf
KausfDecode, err := hex.DecodeString(Kausf)
if err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "KAUSF_DECODE_PROBLEM",
})
return
}
P0 := []byte(snName)
Kseaf, err := ueauth.GetKDFValue(
KausfDecode, ueauth.FC_FOR_KSEAF_DERIVATION, P0, ueauth.KDFLen(P0))
if err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "KSEAF_DERIVATION_PROBLEM",
})
return
}
ausfUeContext.XresStar = authInfoResult.AuthenticationVector.XresStar
ausfUeContext.Kausf = Kausf
ausfUeContext.Kseaf = hex.EncodeToString(Kseaf)
ausfUeContext.Rand = authInfoResult.AuthenticationVector.Rand
responseBody.Var5gAuthData = models.Av5gAka{
Rand: authInfoResult.AuthenticationVector.Rand,
Autn: authInfoResult.AuthenticationVector.Autn,
HxresStar: hxresStar,
}EAP-AKA' 路径(EapAuthComfirmRequestProcedure / eapAkaPrimePrf / CalculateAtMAC):
- 从 UDM 取得
Xres(明文,十六进制字符串)、IkPrime、CkPrime、Rand、Autn。 K_aut = MK[16:48],其中MK由eapAkaPrimePrf(ikPrime, ckPrime, identity)派生(internal/sbi/processor/ue_authentication.go:752)。XMAC = HMAC-SHA256(K_aut, MACInput)[:16],MACInput为攻击者提供的整个 EAP 包(其中 AT_MAC 字段已被解析器就地清零,internal/sbi/processor/ue_authentication.go:810–813)。
这三个关系在源码中分布于 PRF、MAC 计算和 EAP 确认函数,合并阅读如下:
func eapAkaPrimePrf(ikPrime string, ckPrime string, identity string) (
[]byte, []byte, []byte, []byte, []byte,
) {
keyAp := ikPrime + ckPrime
key, _ := hex.DecodeString(keyAp)
sBase := []byte("EAP-AKA'" + identity)
MK := []byte("")
prev := []byte("")
prfRounds := 208/32 + 1
for i := 0; i < prfRounds; i++ {
h := hmac.New(sha256.New, key)
hexNum := byte(i + 1)
ap := append(sBase, hexNum)
s := append(prev, ap...)
_, _ = h.Write(s)
sha := h.Sum(nil)
MK = append(MK, sha...)
prev = sha
}
K_encr := MK[0:16]
K_aut := MK[16:48]
K_re := MK[48:80]
MSK := MK[80:144]
EMSK := MK[144:208]
return K_encr, K_aut, K_re, MSK, EMSK
}
func CalculateAtMAC(key []byte, input []byte) []byte {
h := hmac.New(sha256.New, key)
_, _ = h.Write(input)
return h.Sum(nil)[:16]
}
// EapAuthComfirmRequestProcedure 的 AKA_CHALLENGE_SUBTYPE 分支
K_aut, _ := hex.DecodeString(ausfCurrentContext.K_aut)
XMAC := CalculateAtMAC(K_aut, decodeEapAkaPrimePkt.MACInput)
MAC := decodeEapAkaPrimePkt.Attributes[ausf_context.AT_MAC_ATTRIBUTE].Value
XRES := ausfCurrentContext.XRES
RES := hex.EncodeToString(
decodeEapAkaPrimePkt.Attributes[ausf_context.AT_RES_ATTRIBUTE].Value)
if !bytes.Equal(MAC, XMAC) {
eapOK = false
eapErrStr = "EAP-AKA' integrity check fail"
} else if XRES == RES {
eapSession.AuthResult = models.AusfUeAuthenticationAuthResult_SUCCESS
}AUSF 源码注释引用了
TS 33.501(5G 安全架构)、RFC 5448(EAP-AKA')和RFC 4187(EAP-AKA)。本文未直接引用 3GPP 规范正文及条款号,对协议语义的描述仅建立在源码和上述规范框架之上,不作条款级断言。
1.5 安全不变量(本文的分析基线)
- 机密性不变量:
XRES*(5G-AKA)、XRES/K_aut(EAP-AKA')均为归属网络侧认证材料,只能在 AUSF 进程内按需使用,不得进入可被多个主体读取的普通日志。 - 常数时间比较不变量:比较“攻击者可控值与机密基准值”时,等长输入的执行时间不应取决于首个失配位置。
- 上下文绑定与消费不变量:认证向量与上下文应按 SUPI/SUCI 绑定,并在成功、失败或超时后失效。这是协议与实现都应满足的安全目标。当前仓库中的 5G-AKA 实现只检查映射和上下文是否存在;确认入口既不检查已有的
AuthStatus,也未见删除或 TTL 逻辑。因此,不能将“一次性消费”视为本实现已经提供的防护。
第 1、2 条均有直接的源码与补丁证据。至于第 3 条在协议层面的具体要求,现有仓库无法单独证实;但从实现可以确认,5G-AKA 认证上下文未提供一次性消费或 TTL 过期机制(见 §3.3、§5)。
2. AUSF 认证架构与攻击面
2.1 AUSF 角色与认证分叉
AUSF 不直接面对 UE,而是通过 SBI 与 AMF、UDM 交互:
- 5G-AKA 确认:
PUT /ue-authentications/{authCtxId}/5g-aka-confirmation,比较RES*与XRES*。 - EAP-AKA' 确认:
POST /ue-authentications/{authCtxId}/eap-session,比较AT_MAC与XMAC,再比较RES与XRES。 - 两条路径共享“建立上下文 → 从 UDM 取向量 → 入池 → 确认 → 回传 UDM”的主流程,但比较对象和日志 sink 不同(见 §3.1、§3.2)。
2.2 攻击入口与可控数据
入口 | HTTP 方法/路径 | 攻击者可控数据 | 可控程度 |
E1 |
|
| SBI 调用方可提供;需通过 SUPI/SUCI 与 serving-network 检查,且 UDM 接受 |
E2 |
|
| 需持有已建立的 |
E3 |
|
| 需 base64/EAP/属性结构解析通过; |
EAP-AKA' 确认在本实现的路由表中使用
POST(api_ueauthentication.go:41–44,Method: http.MethodPost),并非部分资料所写的PUT。本文以仓库内实际路由为准。
路由中的 :authCtxId 在 handler 内通过 c.Param 取得;JSON 请求体被反序列化为 models.ConfirmationData,再与 authCtxId 交给 processor。resStar 的可控性可以从 HTTP body 直接追到处理函数实参,而非仅凭函数名推断。
func (s *Server) getUeAuthenticationRoutes() []Route {
return []Route{
{
Name: "EapAuthMethod",
Method: http.MethodPost,
Pattern: "/ue-authentications/:authCtxId/eap-session",
APIFunc: s.HTTPEapAuthMethod,
},
{
Name: "UeAuthenticationsPost",
Method: http.MethodPost,
Pattern: "/ue-authentications",
APIFunc: s.HTTPUeAuthenticationsPost,
},
{
Name: "UeAuthenticationsAuthCtxId5gAkaConfirmationPut",
Method: http.MethodPut,
Pattern: "/ue-authentications/:authCtxId/5g-aka-confirmation",
APIFunc: s.HTTPUeAuthenticationsAuthCtxId5gAkaConfirmationPut,
},
}
}
func (s *Server) HTTPUeAuthenticationsAuthCtxId5gAkaConfirmationPut(c *gin.Context) {
var confirmationData models.ConfirmationData
requestBody, err := c.GetRawData()
if err != nil {
problemDetail := models.ProblemDetails{
Title: "System failure",
Status: http.StatusInternalServerError,
Detail: err.Error(),
Cause: "SYSTEM_FAILURE",
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetail.Cause)
c.JSON(http.StatusInternalServerError, problemDetail)
return
}
err = openapi.Deserialize(&confirmationData, requestBody, "application/json")
if err != nil {
problemDetail := "[Request Body] " + err.Error()
rsp := models.ProblemDetails{
Title: "Malformed request syntax",
Status: http.StatusBadRequest,
Detail: problemDetail,
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetail)
c.JSON(http.StatusBadRequest, rsp)
return
}
confirmationDataResponseId := c.Param("authCtxId")
s.Processor().HandleAuth5gAkaComfirmRequest(c, confirmationData, confirmationDataResponseId)
}EAP 入口采用同样的边界:HTTPEapAuthMethod 从 body 解析 models.EapSession,再把攻击者提供的 EapPayload 与路径中的 authCtxId 传入 EapAuthComfirmRequestProcedure。
func (s *Server) HTTPEapAuthMethod(c *gin.Context) {
var eapSessionReq models.EapSession
requestBody, err := c.GetRawData()
if err != nil {
problemDetail := models.ProblemDetails{
Title: "System failure",
Status: http.StatusInternalServerError,
Detail: err.Error(),
Cause: "SYSTEM_FAILURE",
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetail.Cause)
c.JSON(http.StatusInternalServerError, problemDetail)
return
}
err = openapi.Deserialize(&eapSessionReq, requestBody, "application/json")
if err != nil {
problemDetail := "[Request Body] " + err.Error()
rsp := models.ProblemDetails{
Title: "Malformed request syntax",
Status: http.StatusBadRequest,
Detail: problemDetail,
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetail)
c.JSON(http.StatusBadRequest, rsp)
return
}
eapSessionId := c.Param("authCtxId")
s.Processor().HandleEapAuthComfirmRequest(c, eapSessionReq, eapSessionId)
}2.3 信任边界图(认证状态/信任边界)
XRES*本应只存在于 AUSF 进程的机密域内,但两条 INFO sink 将它写入了日志面(信任域 B)。虚线仅表示可能存在的并发窗口,并不代表已证实的 exploit chain。
2.4 不要混淆两类攻击能力
能力 | 能做什么 | 不能自动获得什么 |
Capability A:远程 SBI 调用者 | 触发认证、提交 | 不自动等于能读取 AUSF 日志 |
Capability B:日志读取者(本地文件、sidecar、采集器、SIEM、被攻陷的容器或进程) | 直接读取 | 不必然具备 AUSF SBI 调用能力;但不应把 |
授权与网络前提:
- 每次请求都经过
RouterAuthorizationCheck.Check(server.go注册、router_auth_check.go实现)。 - 是否要求 OAuth2 由
AUSFContext.OAuth2Required决定。AUSF 注册到 NRF 时,会从 NRF 返回的nf.CustomInfo["oauth2"]读取该值(nrf_service.go:178)。 - 复现环境中的 mock NRF 返回的 NF profile 不包含
customInfo,因此OAuth2Required=false,请求不会被 OAuth 拦截。这不能被泛化为“生产环境中只要端口可达即可调用”;真实部署通常还受 TLS、网络策略和服务网格等控制。
以下三段代码构成完整决策链:路由组注册授权中间件;中间件读取 Authorization 头并调用上下文检查;当 OAuth2Required == false 时,检查函数直接放行。
func newRouter(s *Server) *gin.Engine {
router := logger_util.NewGinWithLogrus(logger.GinLog)
router.Use(metrics.InboundMetrics())
for _, serviceName := range factory.AusfConfig.Configuration.ServiceNameList {
switch models.ServiceName(serviceName) {
case models.ServiceName_NAUSF_AUTH:
ausfUeAuthenticationGroup := router.Group(factory.AusfAuthResUriPrefix)
ausfUeAuthenticationRoutes := s.getUeAuthenticationRoutes()
routerAuthorizationCheck := util.NewRouterAuthorizationCheck(models.ServiceName_NAUSF_AUTH)
ausfUeAuthenticationGroup.Use(func(c *gin.Context) {
routerAuthorizationCheck.Check(c, ausf_context.GetSelf())
})
applyRoutes(ausfUeAuthenticationGroup, ausfUeAuthenticationRoutes)
}
}
return router
}
func (rac *RouterAuthorizationCheck) Check(c *gin.Context, ausfContext ausf_context.NFContext) {
token := c.Request.Header.Get("Authorization")
err := ausfContext.AuthorizationCheck(token, rac.serviceName)
if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
c.Abort()
return
}
}
func (c *AUSFContext) AuthorizationCheck(token string, serviceName models.ServiceName) error {
if !c.OAuth2Required {
logger.UtilLog.Debugf("AUSFContext::AuthorizationCheck: OAuth2 not required\n")
return nil
}
return oauth.VerifyOAuth(token, string(serviceName), c.NrfCertPem)
}OAuth2Required 的值不是本地常量,而是在 NRF 注册响应中动态设置:
nf = res.NrfNfManagementNfProfile
oauth2 := false
if nf.CustomInfo != nil {
v, ok := nf.CustomInfo["oauth2"].(bool)
if ok {
oauth2 = v
logger.MainLog.Infoln("OAuth2 setting receive from NRF:", oauth2)
}
}
ausf_context.GetSelf().OAuth2Required = oauth2
if oauth2 && ausf_context.GetSelf().NrfCertPem == "" {
logger.CfgLog.Error("OAuth2 enable but no nrfCertPem provided in config.")
}状态前提:两处 INFO 泄露点发生在不同阶段。ue_authentication.go:394 在初始 POST /ue-authentications 生成向量时执行,无需后续确认请求;ue_authentication.go:578 和 ue_authentication.go:579 则要求向量已经生成、上下文可通过有效的 authCtxId 取回,且已收到 5G-AKA 确认请求。authCtxId 对应请求中的 supiOrSuci,其到 SUPI 的映射会在 ue_authentication.go:365 以 INFO 级别记录。由于 5G-AKA 确认入口不检查已有的成功或失败状态,实现中没有“仅允许使用未消费上下文”的门控。
3. 根因与漏洞数据流
本节的位置标注沿用 §1.1 的 相对路径:行号 格式。
3.1 最短调用链
链 A1 / A2(UDM 机密 XresStar → 日志 / 比较基准)
链 B(5G-AKA 确认:resStar → strings.EqualFold)
Auth5gAkaComfirmRequestProcedure/HandleAuth5gAkaComfirmRequest中的Comfirm是上游源码拼写(正确拼法应为 Confirm),下文沿用源码名称。
链 C(EAP-AKA' 确认:eapPayload → bytes.Equal / ==)
3.2 变量追踪表(source-to-sink)
变量 | 类型 | 来源 | 赋值位置 | 业务校验 | 最终用途 |
|
| HTTP JSON |
| 无 |
|
|
| UDM 响应 |
| 无 |
|
|
| 上者写入 |
| 无 | 日志( |
|
| 攻击者 |
| 仅解析边界检查 |
|
|
| UDM 向量 + AUSF 派生 |
| 无 | 比较基准 / 完整性密钥( |
编码与类型说明:问题不在数据长度,而在于如何进行相等性比较,以及机密值是否被写入日志。%x 会逐字节对 string 做十六进制编码;该编码无损且可逆,仍会泄露机密(“0123…” → “3031…”)。
3.3 认证上下文生命周期
AusfUeContext 是本漏洞中机密值的存储介质。
context.go 除定义机密字段外,还定义了两张 sync.Map 及其存取函数。UePool.Store 保存的是 *AusfUeContext 指针,而非结构体副本;后文对“入池后继续写字段”的分析以此为前提。
type AUSFContext struct {
suciSupiMap sync.Map
UePool sync.Map
// ... NF 配置与服务状态字段 ...
OAuth2Required bool
}
type AusfUeContext struct {
Supi string
Kausf string
Kseaf string
ServingNetworkName string
AuthStatus models.AusfUeAuthenticationAuthResult
UdmUeauUrl string
// for 5G AKA
XresStar string
// for EAP-AKA'
K_aut string
XRES string
Rand string
EapID uint8
Resynced bool
}
func NewAusfUeContext(identifier string) *AusfUeContext {
ausfUeContext := new(AusfUeContext)
ausfUeContext.Supi = identifier
return ausfUeContext
}
func AddAusfUeContextToPool(ausfUeContext *AusfUeContext) {
ausfContext.UePool.Store(ausfUeContext.Supi, ausfUeContext)
}
func GetAusfUeContext(ref string) *AusfUeContext {
context, _ := ausfContext.UePool.Load(ref)
return context.(*AusfUeContext)
}
func AddSuciSupiPairToMap(supiOrSuci string, supi string) {
newPair := new(SuciSupiMap)
newPair.SupiOrSuci = supiOrSuci
newPair.Supi = supi
ausfContext.suciSupiMap.Store(supiOrSuci, newPair)
}
func GetSupiFromSuciSupiMap(ref string) string {
val, _ := ausfContext.suciSupiMap.Load(ref)
return val.(*SuciSupiMap).Supi
}阶段 | 位置 | 行为 |
创建 |
|
|
入池 |
|
|
建映射 |
|
|
字段填充 |
|
|
读取 |
|
|
删除/过期/TTL | 未发现 | 全仓未见 |
5G-AKA 确认状态门控 | 未发现 |
|
仓库虽然注册了删除路由,但两个与本文相关的 handler 都只返回 501 Not Implemented,所以不能把它们视为已实现的上下文消费机制:
func (s *Server) HTTPDelete5gAkaAuthenticationResult(c *gin.Context) {
c.JSON(http.StatusNotImplemented, gin.H{})
}
func (s *Server) HTTPDeleteEapAuthenticationResult(c *gin.Context) {
c.JSON(http.StatusNotImplemented, gin.H{})
}入池后字段的写入顺序(这既解释了 CodeQL 断点,也提示了潜在并发风险):
ausfUeContext := ausf_context.NewAusfUeContext(ueid)
ausfUeContext.ServingNetworkName = snName
ausfUeContext.AuthStatus = models.AusfUeAuthenticationAuthResult_ONGOING
ausfUeContext.UdmUeauUrl = udmUrl
ausf_context.AddAusfUeContextToPool(ausfUeContext)
logger.UeAuthLog.Infof("Add SuciSupiPair (%s, %s) to map.\n", supiOrSuci, ueid)
ausf_context.AddSuciSupiPairToMap(supiOrSuci, ueid)
locationURI := self.Url + factory.AusfAuthResUriPrefix + "/ue-authentications/" + supiOrSuci
putLink := locationURI
switch authInfoResult.AuthType {
case models.UdmUeauAuthType__5_G_AKA:
ausfUeContext.XresStar = authInfoResult.AuthenticationVector.XresStar
ausfUeContext.Kausf = Kausf
ausfUeContext.Kseaf = hex.EncodeToString(Kseaf)
ausfUeContext.Rand = authInfoResult.AuthenticationVector.Rand
}sync.Map 的 Store/Load 只保证映射操作本身的并发安全,不会同步存入指针所指字段的后续写入。若确认请求恰好在 internal/sbi/processor/ue_authentication.go:363–427 的窗口中取回对象,可能读到零值,亦可能形成数据竞争。本文未通过 -race 或并发实验将其确认为独立漏洞,因此仅将其列为需要单独验证的并发风险。
UDM 通知次数(通过 mock UDM 请求计数验证):
- 5G-AKA 失败路径:
internal/sbi/processor/ue_authentication.go:589的logConfirmFailureAndInformUDM内部调用一次SendAuthResultToUDM,函数末尾又调用一次,因此失败请求会通知 两次。 - 5G-AKA 成功路径:只在函数末尾调用一次,因此成功请求会通知 一次。
- 实测一次失败和一次成功共生成 3 次
/auth-events,与源码分析一致。这是粗粒度差异,而且成功或失败本就能从响应中观察到。修复版行为相同(§6.4),说明补丁没有改变这部分逻辑。
失败分支的第一次通知封装在下列 helper 中;第二次是 §3.4.1 完整函数末尾的无条件 SendAuthResultToUDM。
func (p *Processor) logConfirmFailureAndInformUDM(
id string,
authType models.AusfUeAuthenticationAuthType,
servingNetworkName, errStr, udmUrl string,
) {
udmAuthType := models.UdmUeauAuthType(authType)
switch authType {
case models.AusfUeAuthenticationAuthType__5_G_AKA:
logger.Auth5gAkaLog.Infoln(servingNetworkName, errStr)
if sendErr := p.Consumer().SendAuthResultToUDM(
id, udmAuthType, false, "", udmUrl); sendErr != nil {
logger.Auth5gAkaLog.Infoln(sendErr.Error())
}
case models.AusfUeAuthenticationAuthType_EAP_AKA_PRIME:
logger.AuthELog.Infoln(errStr)
if sendErr := p.Consumer().SendAuthResultToUDM(
id, udmAuthType, false, "", udmUrl); sendErr != nil {
logger.AuthELog.Infoln(sendErr.Error())
}
}
}计数命令和容器内实测结果如下(脆弱版与修复版分别为 3):
docker compose logs udm 2>/dev/null | grep -c auth-events
docker compose -f docker-compose.fixed.yml logs udm 2>/dev/null | grep -c auth-events确认请求可以重试或重放:§4.1 使用同一 authCtxId 完成了“错误 RES* → AUTHENTICATION_FAILURE → 正确 RES* → AUTHENTICATION_SUCCESS”的序列。5G-AKA 确认函数不将 AuthStatus 作为前置条件,比较成功后会返回 SUPI 和 Kseaf。这说明前一次失败不会消费上下文;成功后,该逻辑也不会阻止上下文再次进入比较。真实部署中能否据此完成未授权认证,仍取决于调用方的 SBI 权限和 UDM 对认证事件的处理。
3.4 关键源码逐函数分析
3.4.1 Auth5gAkaComfirmRequestProcedure(internal/sbi/processor/ue_authentication.go:543,5G-AKA 分支)
func (p *Processor) Auth5gAkaComfirmRequestProcedure(
c *gin.Context,
updateConfirmationData models.ConfirmationData,
ConfirmationDataResponseID string,
) {
var confirmDataRsp models.ConfirmationDataResponse
success := false
confirmDataRsp.AuthResult = models.AusfUeAuthenticationAuthResult_FAILURE
if !ausf_context.CheckIfSuciSupiPairExists(ConfirmationDataResponseID) {
logger.Auth5gAkaLog.Infof(
"supiSuciPair does not exist, confirmation failed (queried by %s)\n",
ConfirmationDataResponseID)
problemDetails := models.ProblemDetails{
Cause: "USER_NOT_FOUND",
Status: http.StatusBadRequest,
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetails.Cause)
c.JSON(http.StatusBadRequest, problemDetails)
return
}
currentSupi := ausf_context.GetSupiFromSuciSupiMap(ConfirmationDataResponseID)
if !ausf_context.CheckIfAusfUeContextExists(currentSupi) {
logger.Auth5gAkaLog.Infof(
"SUPI does not exist, confirmation failed (queried by %s)\n", currentSupi)
problemDetails := models.ProblemDetails{
Cause: "USER_NOT_FOUND",
Status: http.StatusBadRequest,
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetails.Cause)
c.JSON(http.StatusBadRequest, problemDetails)
return
}
ausfCurrentContext := ausf_context.GetAusfUeContext(currentSupi)
servingNetworkName := ausfCurrentContext.ServingNetworkName
// Compare the received RES* with the stored XRES*
logger.Auth5gAkaLog.Infof("res*: %x\nXres*: %x\n",
updateConfirmationData.ResStar, ausfCurrentContext.XresStar)
if strings.EqualFold(updateConfirmationData.ResStar, ausfCurrentContext.XresStar) {
ausfCurrentContext.AuthStatus = models.AusfUeAuthenticationAuthResult_SUCCESS
confirmDataRsp.AuthResult = models.AusfUeAuthenticationAuthResult_SUCCESS
success = true
logger.Auth5gAkaLog.Infoln("5G AKA confirmation succeeded")
confirmDataRsp.Supi = currentSupi
confirmDataRsp.Kseaf = ausfCurrentContext.Kseaf
} else {
ausfCurrentContext.AuthStatus = models.AusfUeAuthenticationAuthResult_FAILURE
confirmDataRsp.AuthResult = models.AusfUeAuthenticationAuthResult_FAILURE
p.logConfirmFailureAndInformUDM(
ConfirmationDataResponseID,
models.AusfUeAuthenticationAuthType__5_G_AKA,
servingNetworkName,
"5G AKA confirmation failed",
ausfCurrentContext.UdmUeauUrl)
}
if sendErr := p.Consumer().SendAuthResultToUDM(
currentSupi,
models.UdmUeauAuthType__5_G_AKA,
success,
servingNetworkName,
ausfCurrentContext.UdmUeauUrl); sendErr != nil {
logger.Auth5gAkaLog.Infoln(sendErr.Error())
problemDetails := models.ProblemDetails{
Status: http.StatusInternalServerError,
Cause: "UPSTREAM_SERVER_ERROR",
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetails.Cause)
c.JSON(http.StatusInternalServerError, problemDetails)
return
}
c.JSON(http.StatusOK, confirmDataRsp)
}- 输入:
ResStar来自 JSON 反序列化,对持有有效authCtxId的调用方完全可控。 - 前置检查:只检查映射和上下文是否存在,没有校验
ResStar的格式、长度或来源。 internal/sbi/processor/ue_authentication.go:578:日志在比较前无条件执行,因此无论resStar是否正确,XresStar都会被输出。internal/sbi/processor/ue_authentication.go:579:strings.EqualFold不区分大小写,但不是常数时间实现。
3.4.2 UeAuthPostRequestProcedure(internal/sbi/processor/ue_authentication.go:242,5G-AKA 分支)
func (p *Processor) UeAuthPostRequestProcedure(
c *gin.Context,
updateAuthenticationInfo models.AuthenticationInfo,
) {
var responseBody models.UeAuthenticationCtx
var authInfoReq models.AuthenticationInfoRequest
supiOrSuci := updateAuthenticationInfo.SupiOrSuci
snName := updateAuthenticationInfo.ServingNetworkName
self := ausf_context.GetSelf()
authInfoReq.ServingNetworkName = snName
authInfoReq.AusfInstanceId = self.GetSelfID()
udmUrl, err := p.Consumer().GetUdmUrl(self.NrfUri)
if err != nil {
c.JSON(http.StatusServiceUnavailable, openapi.ProblemDetailsSystemFailure(err.Error()))
return
}
result, err := p.Consumer().GenerateAuthDataApi(udmUrl, supiOrSuci, authInfoReq)
if err != nil {
c.JSON(http.StatusInternalServerError, openapi.ProblemDetailsSystemFailure(err.Error()))
return
}
authInfoResult := *result
ueid := authInfoResult.Supi
ausfUeContext := ausf_context.NewAusfUeContext(ueid)
ausfUeContext.ServingNetworkName = snName
ausfUeContext.AuthStatus = models.AusfUeAuthenticationAuthResult_ONGOING
ausfUeContext.UdmUeauUrl = udmUrl
ausf_context.AddAusfUeContextToPool(ausfUeContext)
logger.UeAuthLog.Infof("Add SuciSupiPair (%s, %s) to map.\n", supiOrSuci, ueid)
ausf_context.AddSuciSupiPairToMap(supiOrSuci, ueid)
locationURI := self.Url + factory.AusfAuthResUriPrefix + "/ue-authentications/" + supiOrSuci
putLink := locationURI
switch authInfoResult.AuthType {
case models.UdmUeauAuthType__5_G_AKA:
logger.UeAuthLog.Infoln("Use 5G AKA auth method")
putLink += "/5g-aka-confirmation"
// Derive HXRES* from XRES*
concat := authInfoResult.AuthenticationVector.Rand +
authInfoResult.AuthenticationVector.XresStar
var hxresStarBytes []byte
if bytes, err := hex.DecodeString(concat); err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "CONCAT_DECODE_PROBLEM",
})
return
} else {
hxresStarBytes = bytes
}
hxresStarAll := sha256.Sum256(hxresStarBytes)
hxresStar := hex.EncodeToString(hxresStarAll[16:]) // last 128 bits
logger.Auth5gAkaLog.Infof("XresStar = %x\n",
authInfoResult.AuthenticationVector.XresStar)
// Derive Kseaf from Kausf
Kausf := authInfoResult.AuthenticationVector.Kausf
var KausfDecode []byte
if ausfDecode, err := hex.DecodeString(Kausf); err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "KAUSF_DECODE_PROBLEM",
})
return
} else {
KausfDecode = ausfDecode
}
P0 := []byte(snName)
Kseaf, err := ueauth.GetKDFValue(
KausfDecode, ueauth.FC_FOR_KSEAF_DERIVATION, P0, ueauth.KDFLen(P0))
if err != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "KSEAF_DERIVATION_PROBLEM",
})
return
}
ausfUeContext.XresStar = authInfoResult.AuthenticationVector.XresStar
ausfUeContext.Kausf = Kausf
ausfUeContext.Kseaf = hex.EncodeToString(Kseaf)
ausfUeContext.Rand = authInfoResult.AuthenticationVector.Rand
var av5gAka models.Av5gAka
av5gAka.Rand = authInfoResult.AuthenticationVector.Rand
av5gAka.Autn = authInfoResult.AuthenticationVector.Autn
av5gAka.HxresStar = hxresStar
responseBody.Var5gAuthData = av5gAka
linksValue := models.Link{Href: putLink}
responseBody.Links = make(map[string][]models.Link)
responseBody.Links["5g-aka"] = []models.Link{linksValue}
}
}internal/sbi/processor/ue_authentication.go:394:第一次泄露发生在认证上下文建立阶段,早于确认请求。internal/sbi/processor/ue_authentication.go:427:机密值被写入上下文对象,是其在进程内继续传播的关键一步。
3.4.3 EapAuthComfirmRequestProcedure(internal/sbi/processor/ue_authentication.go:40)
func (p *Processor) EapAuthComfirmRequestProcedure(
c *gin.Context,
updateEapSession models.EapSession,
eapSessionID string,
) {
var eapSession models.EapSession
if !ausf_context.CheckIfSuciSupiPairExists(eapSessionID) {
c.JSON(http.StatusNotFound, models.ProblemDetails{
Status: http.StatusNotFound,
Cause: "USER_NOT_FOUND",
})
return
}
currentSupi := ausf_context.GetSupiFromSuciSupiMap(eapSessionID)
if !ausf_context.CheckIfAusfUeContextExists(currentSupi) {
c.JSON(http.StatusNotFound, models.ProblemDetails{
Status: http.StatusNotFound,
Cause: "USER_NOT_FOUND",
})
return
}
ausfCurrentContext := ausf_context.GetAusfUeContext(currentSupi)
servingNetworkName := ausfCurrentContext.ServingNetworkName
if ausfCurrentContext.AuthStatus == models.AusfUeAuthenticationAuthResult_FAILURE {
eapSession.AuthResult = models.AusfUeAuthenticationAuthResult_FAILURE
c.JSON(http.StatusUnauthorized, eapSession)
return
}
var eapPayload []byte
if eapPayloadTmp, err := base64.StdEncoding.DecodeString(
updateEapSession.EapPayload); err != nil {
logger.AuthELog.Warnf("EAP Payload decode failed: %+v", err)
} else {
eapPayload = eapPayloadTmp
}
eapGoPkt := gopacket.NewPacket(eapPayload, layers.LayerTypeEAP, gopacket.Default)
eapLayer := eapGoPkt.Layer(layers.LayerTypeEAP)
eapContent, ok := eapLayer.(*layers.EAP)
if !ok || eapContent == nil {
c.JSON(http.StatusBadRequest, models.ProblemDetails{
Status: http.StatusBadRequest,
Cause: "INVALID_EAP_PAYLOAD",
})
return
}
eapOK := true
var eapErrStr string
if eapContent.Code != layers.EAPCodeResponse {
eapOK = false
eapErrStr = "eap packet code error"
} else if eapContent.Type != ausf_context.EAP_AKA_PRIME_TYPENUM {
eapOK = false
eapErrStr = "eap packet type error"
} else if decodeEapAkaPrimePkt, err := decodeEapAkaPrime(eapContent.Contents); err != nil {
eapOK = false
eapErrStr = "eap packet error"
} else {
switch decodeEapAkaPrimePkt.Subtype {
case ausf_context.AKA_CHALLENGE_SUBTYPE:
K_autStr := ausfCurrentContext.K_aut
var K_aut []byte
if K_autTmp, err := hex.DecodeString(K_autStr); err != nil {
logger.AuthELog.Warnf("K_aut decode error: %+v", err)
} else {
K_aut = K_autTmp
}
XMAC := CalculateAtMAC(K_aut, decodeEapAkaPrimePkt.MACInput)
MAC := decodeEapAkaPrimePkt.Attributes[ausf_context.AT_MAC_ATTRIBUTE].Value
XRES := ausfCurrentContext.XRES
RES := hex.EncodeToString(
decodeEapAkaPrimePkt.Attributes[ausf_context.AT_RES_ATTRIBUTE].Value)
if !bytes.Equal(MAC, XMAC) {
eapOK = false
eapErrStr = "EAP-AKA' integrity check fail"
} else if XRES == RES {
logger.AuthELog.Infoln("Correct RES value, EAP-AKA' auth succeed")
eapSession.KSeaf = ausfCurrentContext.Kseaf
eapSession.Supi = currentSupi
eapSession.AuthResult = models.AusfUeAuthenticationAuthResult_SUCCESS
eapSession.EapPayload = ConstructEapNoTypePkt(
radius.EapCodeSuccess, eapContent.Id)
if sendErr := p.Consumer().SendAuthResultToUDM(
currentSupi,
models.UdmUeauAuthType_EAP_AKA_PRIME,
true,
servingNetworkName,
ausfCurrentContext.UdmUeauUrl); sendErr != nil {
c.JSON(http.StatusInternalServerError, models.ProblemDetails{
Cause: "UPSTREAM_SERVER_ERROR",
})
return
}
ausfCurrentContext.AuthStatus = models.AusfUeAuthenticationAuthResult_SUCCESS
} else {
eapOK = false
eapErrStr = "Wrong RES value, EAP-AKA' auth failed"
}
}
}
if !eapOK {
logger.AuthELog.Warnf("EAP-AKA' failure: %s", eapErrStr)
_ = p.Consumer().SendAuthResultToUDM(
currentSupi,
models.UdmUeauAuthType_EAP_AKA_PRIME,
false,
servingNetworkName,
ausfCurrentContext.UdmUeauUrl)
ausfCurrentContext.AuthStatus = models.AusfUeAuthenticationAuthResult_FAILURE
}
c.JSON(http.StatusOK, eapSession)
}bytes.Equal和==都不是常数时间比较。XRES == RES以前置的bytes.Equal(MAC, XMAC)校验为门控条件:只有先通过 AT_MAC 校验才会进入 RES 比较,而构造有效 AT_MAC 需要会话特定的K_aut。因此,这条分支的定时信号更难获得。
3.4.4 decodeEapAkaPrime 与 CalculateAtMAC(internal/sbi/processor/ue_authentication.go:759、ue_authentication.go:637)
decodeEapAkaPrime(internal/sbi/processor/ue_authentication.go:759)包含防止越界读取的边界检查,并校验属性长度,例如 AT_MAC 的 attrLen==20、AT_RES 为 4–16 字节。但它不限制 AT_MAC / AT_RES 的具体字节内容,攻击者提供的值会原样进入比较。这里的重点不是越界,而是攻击者可控字节进入了短路比较。
func decodeEapAkaPrime(eapPkt []byte) (*ausf_context.EapAkaPrimePkt, error) {
var decodePkt ausf_context.EapAkaPrimePkt
var attrLen int
var decodeAttr ausf_context.EapAkaPrimeAttribute
attributes := make(map[uint8]ausf_context.EapAkaPrimeAttribute)
// Bounds-check the EAP header before slicing.
if len(eapPkt) < 6 {
return nil, fmt.Errorf("EAP-AKA' packet too short: got %d bytes, need at least 6", len(eapPkt))
}
data := eapPkt[5:]
decodePkt.Subtype = data[0]
dataLen := len(data)
// decode attributes
for i := 3; i < dataLen; i += attrLen {
// Bounds-check the 2-byte attribute header.
if i+1 >= dataLen {
return nil, fmt.Errorf("EAP-AKA' attribute header truncated at offset %d", i)
}
attrType := data[i]
attrLen = int(data[i+1]) * 4
if attrLen == 0 {
return nil, fmt.Errorf("attribute length equal to zero")
}
if i+attrLen > dataLen {
return nil, fmt.Errorf("packet length out of range")
}
switch attrType {
case ausf_context.AT_RES_ATTRIBUTE:
logger.AuthELog.Tracef("Decoding AT_RES\n")
accLen := int(data[i+3] >> 3)
if accLen > 16 || accLen < 4 || accLen+4 > attrLen {
return nil, fmt.Errorf("attribute AT_RES decode err")
}
decodeAttr.Type = attrType
decodeAttr.Length = data[i+1]
decodeAttr.Value = data[i+4 : i+4+accLen]
attributes[attrType] = decodeAttr
case ausf_context.AT_MAC_ATTRIBUTE:
logger.AuthELog.Tracef("Decoding AT_MAC\n")
if attrLen != 20 {
return nil, fmt.Errorf("attribute AT_MAC decode err")
}
decodeAttr.Type = attrType
decodeAttr.Length = data[i+1]
Mac := make([]byte, attrLen-4)
copy(Mac, data[i+4:i+attrLen])
decodeAttr.Value = Mac
attributes[attrType] = decodeAttr
// clean AT_MAC value for integrity check later
zeros := make([]byte, attrLen-4)
copy(data[i+4:i+attrLen], zeros)
decodePkt.MACInput = eapPkt
}
}
if decodePkt.Subtype == ausf_context.AKA_CHALLENGE_SUBTYPE {
if _, ok := attributes[ausf_context.AT_RES_ATTRIBUTE]; !ok {
return nil, fmt.Errorf("AKA-Challenge attributes error")
} else if _, ok := attributes[ausf_context.AT_MAC_ATTRIBUTE]; !ok {
return nil, fmt.Errorf("AKA-Challenge attributes error")
}
}
decodePkt.Attributes = attributes
return &decodePkt, nil
}CalculateAtMAC(internal/sbi/processor/ue_authentication.go:637)计算 XMAC = HMAC-SHA256(K_aut, MACInput)[:16]。攻击者可完全控制 HMAC 消息 MACInput,但并不知道密钥 K_aut,因而无法直接构造与 XMAC 相等的 AT_MAC。bytes.Equal 不提供密码学意义上的常数时间承诺;实际比较粒度则取决于 Go 版本和体系结构中的 memequal 实现。不能仅因选用了该 API,就断言存在可逐字节利用的 XMAC 预言机。本文仅将其判定为应修复的非常数时间比较,不声称已经完成逐字节恢复。
func CalculateAtMAC(key []byte, input []byte) []byte {
// keyed with K_aut
h := hmac.New(sha256.New, key)
if _, err := h.Write(input); err != nil {
logger.AuthELog.Errorln(err.Error())
}
sum := h.Sum(nil)
return sum[:16]
}3.5 根因
根因很直接:AUSF 将认证材料视为普通字符串或字节数组,既用通用相等性函数比较,又将其写入常规 INFO 日志,从而同时破坏了常数时间比较和机密数据的边界。
这不是简单的“缺少输入校验”。对于日志泄露,再增加一层
if也无法改变XRES*已被打印的事实;问题也不只是“调用了危险函数”,而是将具有机密语义的数据放入了普通数据的处理路径。
4. 复现与测量
4.1 复现 A:日志泄露(端到端)
以下复现仅在隔离的本地 Docker 环境中执行。mock NRF/UDM 使用 §1.2 的脱敏固定向量,既不能连接真实运营商网络,也不可用于此类网络。前置条件为 Docker Engine、Docker Compose v2 和 curl;命令应在本文配套目录的根目录执行。该目录需包含 ausf/、mockcore/ 及各自的 Dockerfile,其中 ausf/ 是本文分析的脆弱源码。
编排启动三个服务:mock NRF(宿主机 18001)、mock UDM(18002)和脆弱 AUSF(18000)。三者位于独立的 bridge 网络,AUSF 会等待 NRF 健康检查成功后再启动。docker-compose.yml 如下:
services:
nrf:
build:
context: ./mockcore
dockerfile: Dockerfile
image: cve-2026-55785-mockcore:1.0.0
container_name: cve-2026-55785-nrf
environment:
NRF_SELF_URL: "http://nrf:8000"
UDM_SELF_URL: "http://udm:8000"
ports:
- "${NRF_HOST_PORT:-18001}:8000"
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8000/nnrf-disc/v1/nf-instances"]
interval: 5s
timeout: 3s
retries: 12
start_period: 2s
networks: [core]
udm:
build:
context: ./mockcore
dockerfile: Dockerfile
image: cve-2026-55785-mockcore:1.0.0
container_name: cve-2026-55785-udm
environment:
NRF_SELF_URL: "http://nrf:8000"
UDM_SELF_URL: "http://udm:8000"
ports:
- "${UDM_HOST_PORT:-18002}:8000"
networks: [core]
ausf:
build:
context: ./ausf
dockerfile: Dockerfile
image: cve-2026-55785-ausf:1.0.0
container_name: cve-2026-55785-ausf
depends_on:
nrf:
condition: service_healthy
ports:
- "${AUSF_HOST_PORT:-18000}:8000"
networks: [core]
networks:
core:
driver: bridge
name: cve-2026-55785-core将上述配置保存为根目录的 docker-compose.yml 后,依次启动栈、建立认证上下文、提交错误的 RES*、再提交正确的 RES*,最后筛选日志。所有请求均为正常的 5G-AKA 流程输入,无需构造畸形报文;第二次确认复用同一 authCtxId(本 mock 中即 SUPI)。
docker compose up -d --build
AUSF_URL=http://127.0.0.1:18000
BASE="$AUSF_URL/nausf-auth/v1"
SUPI=imsi-2089300007487
curl -i -X POST "$BASE/ue-authentications" -H 'Content-Type: application/json' \
-d '{"supiOrSuci":"imsi-2089300007487","servingNetworkName":"5G:mnc070.mcc208.3gppnetwork.org"}'
curl -i -X PUT "$BASE/ue-authentications/$SUPI/5g-aka-confirmation" -H 'Content-Type: application/json' \
-d '{"resStar":"00000000000000000000000000000000"}'
curl -i -X PUT "$BASE/ue-authentications/$SUPI/5g-aka-confirmation" -H 'Content-Type: application/json' \
-d '{"resStar":"0123456789abcdef0123456789abcdef"}'
docker compose logs ausf | grep -E 'XresStar|Xres\*|res\*'预期结果为:POST 返回 201 Created;错误的 resStar 返回 AUTHENTICATION_FAILURE;正确的 resStar 返回 AUTHENTICATION_SUCCESS。最后一条命令应在日志中命中 XresStar、res* 或 Xres*,并显示正确值的 ASCII 十六进制编码 303132...。若 AUSF 尚未就绪,可先执行 docker compose ps,待 ausf 运行后再重试请求。
下图为在容器中真实执行 verify.sh 的完整过程(脆弱版):
再单独 grep AUSF 日志,可以更清楚地看到 XresStar / res* / Xres* 泄露行(保留容器名与时间戳,未脱敏内容):
脆弱版运行记录如下,包含 HTTP 状态、响应体、同一 authCtxId 的失败后重试,以及 INFO 日志中的三个泄露点。
=====================================================================
CVE-2026-55785 reproduction: free5GC AUSF XRES* log leak
=====================================================================
AUSF_URL = http://host.docker.internal:18000
SUPI = imsi-2089300007487
SERVING_NET = 5G:mnc070.mcc208.3gppnetwork.org
XRES_STAR = 0123456789abcdef0123456789abcdef
WRONG_RES_STAR = 00000000000000000000000000000000
[*] AUSF is up.
[1/3] POST /ue-authentications (5G-AKA vector generation)
HTTP/1.1 201 Created
Location: http://ausf:8000/nausf-auth/v1/ue-authentications/imsi-2089300007487
{"authType":"5G_AKA","5gAuthData":{"rand":"b8a6c1d2e3f405162738495a6b7c8d9e","hxresStar":"32fce32908072a0d3b931066ea187199","autn":"5449ab1c9c91f9f60000000000000000"},"_links":{"5g-aka":[{"href":"http://ausf:8000/nausf-auth/v1/ue-authentications/imsi-2089300007487/5g-aka-confirmation"}]},"servingNetworkName":"5G:mnc070.mcc208.3gppnetwork.org"}
[2/3] PUT /ue-authentications/imsi-2089300007487/5g-aka-confirmation (WRONG RES*)
HTTP/1.1 200 OK
{"authResult":"AUTHENTICATION_FAILURE"}
[3/3] PUT /ue-authentications/imsi-2089300007487/5g-aka-confirmation (CORRECT RES*)
HTTP/1.1 200 OK
{"authResult":"AUTHENTICATION_SUCCESS","supi":"imsi-2089300007487","kseaf":"e9e4cd8fa1e5c8bc4afd343a41bcc1f4a70a9fafdd8456245d91a1e4046ce229"}
[*] Inspecting AUSF logs for the leaked expected-response value (XRES*)...
cve-2026-55785-ausf | 2026-09-03T10:22:45.006215876Z [INFO][AUSF][5gAka] XresStar = 3031323334353637383961626364656630313233343536373839616263646566
cve-2026-55785-ausf | 2026-09-03T10:22:45.012083167Z [INFO][AUSF][5gAka] res*: 3030303030303030303030303030303030303030303030303030303030303030
cve-2026-55785-ausf | Xres*: 3031323334353637383961626364656630313233343536373839616263646566
cve-2026-55785-ausf | 2026-09-03T10:22:45.017919084Z [INFO][AUSF][5gAka] res*: 3031323334353637383961626364656630313233343536373839616263646566
cve-2026-55785-ausf | Xres*: 3031323334353637383961626364656630313233343536373839616263646566
SUCCESS: XRES* (expected authentication response) was written to the AUSF INFO log.日志为何出现 303132...:脆弱代码用 %x 格式化 Go string,fmt 会输出字符串每个字节的十六进制表示。因此,"0123456789abcdef..." 会变成其 ASCII 字节序列对应的 303132...。这不是哈希或脱敏,而是无损、可逆的编码;泄露的仍是完整 XRES*。
验证判定:
- 向量生成阶段出现
XresStar = ...; - 确认阶段出现
res*:与Xres*:成对行; - 该值等于 mock UDM 固定返回的
XRES* = 0123456789abcdef0123456789abcdef的%x编码(303132...)。
4.2 复现 B:非常数时间比较(本地 CPU 微基准)
原有 timing-bench/main.go 以 time.Now 展示趋势。为降低计时框架本身的干扰,本文改用 Go 标准库的 testing.B。初版 bench_test.go 在手写的 for i < b.N 循环中丢弃比较结果,编译器因而消除了 bytes.Equal 与 subtle.ConstantTimeCompare 的实质工作;旧的 ~0.31 ns/op / ~6.8 ns/op 对照数据不能作为证据,已撤回。修正版使用 Go 1.24 引入的 b.Loop(),以确保循环内调用及参数保持存活。
基准并非只比较“正确/错误”两种结果,而是在总长度不变的条件下,将首个失配点从第 0 位逐步移至末尾。以下给出 strings.EqualFold 与修复版语义对应的完整基准函数;bytes.Equal / subtle.ConstantTimeCompare 用例采用相同的 16 字节前缀构造方法。
const hexFixture = "0123456789abcdef0123456789abcdef"
func fixedConstantTimeHexEqual(a, b string) bool {
aBytes, err := hex.DecodeString(a)
if err != nil {
return false
}
bBytes, err := hex.DecodeString(b)
if err != nil {
return false
}
return len(aBytes) == len(bBytes) &&
subtle.ConstantTimeCompare(aBytes, bBytes) == 1
}
func BenchmarkCompareEqualFold(b *testing.B) {
a := hexFixture
for prefix := 0; prefix <= 32; prefix++ {
x := []byte(a)
if prefix < 32 {
if x[prefix] == 'f' {
x[prefix] = 'e'
} else {
x[prefix] = 'f'
}
}
s := string(x)
b.Run(mkName("equalFold", prefix), func(b *testing.B) {
b.ReportAllocs()
for b.Loop() {
_ = strings.EqualFold(a, s)
}
})
}
}
func BenchmarkCompareConstantTimeHexEqual(b *testing.B) {
a := hexFixture
for prefix := 0; prefix <= 32; prefix++ {
x := []byte(a)
if prefix < 32 {
if x[prefix] == 'f' {
x[prefix] = 'e'
} else {
x[prefix] = 'f'
}
}
s := string(x)
b.Run(mkName("constantTimeHexEqual", prefix), func(b *testing.B) {
b.ReportAllocs()
for b.Loop() {
_ = fixedConstantTimeHexEqual(a, s)
}
})
}
}方法:
docker build --target builder \
-t cve-2026-55785-bench-builder:corrected timing-bench
docker run --rm cve-2026-55785-bench-builder:corrected /bin/sh -c \
"go test -run '^$' \
-bench='BenchmarkCompare.*/.*/prefix=(00|08|15|16|24|31|32)$' \
-benchtime=500000x -count=10 -benchmem ."修正后的测试环境为 go1.26.3 linux/arm64(Apple M2 / Docker Desktop),GOMAXPROCS=8。测试选取代表性的失配位置,每个用例执行 500000 次迭代、共 count=10 轮。另以 -gcflags=-S 核对编译产物:bytes.Equal 基准体保留了 CALL runtime.memequal,ConstantTimeCompare 基准体保留了逐字节 MOVBU / EOR / ORR 循环,确认比较操作未再次被优化掉。
- CPU 频率和 governor 未固定,也未显式绑定核心(共享 Docker Desktop VM 内核)。因此,绝对 ns/op 仅供参考;趋势与编译产物才是主要观察指标。
汇总结果(ns/op,10 轮中位数的代表范围):
原语 | 输入 | prefix 低 → 高 | 趋势 |
| 32 hex 字符 | prefix 0/8/16/24/31:~1.93 / 5.72 / 9.45 / 13.22 / 16.54 | 首个失配位置越后,总体耗时越高 |
| 32 hex 字符 | 代表位置约 ~55.7–56.1 | 未见随失配位置的系统变化 |
| 16 字节 | prefix 0/8/15/16:~2.66 / 2.74 / 2.63 / 2.91 | 实现呈现块级/完全相等路径差异,无逐字节单调趋势 |
| 16 字节 | 代表位置约 ~6.69–7.01 | 未见随失配位置的系统变化 |
结论(局限到该实现/该测量方法):
strings.EqualFold的耗时与首个失配位置明显相关,是本环境最清晰的比较器级信号。constantTimeHexEqual与subtle.ConstantTimeCompare在本测试的合法、等长输入上未见随失配位置的系统变化;这不包含解析错误和长度分支。- 16 字节
bytes.Equal在本 Go/linux/arm64 实现上约为 2.6–2.9 ns/op,没有出现随前缀 0→15 逐字节单调上升的趋势。汇编表明它经由runtime.memequal执行;不同 Go 版本和体系结构可使用不同实现,因此结果只能支持“无常数时间承诺”,不能支持“可逐字节恢复 XMAC”。
测量环境为 Apple M2 上 Docker Desktop 的 go1.26.3 linux/arm64,GOMAXPROCS=8。汇编检查确认保留了 runtime.memequal 与 MOVBU/EOR/ORR 循环;七个选定 prefix 的十轮中位数已列于上表。这组微基准不足以单独支持任何关于远程可利用性的结论(见 §5)。
4.3 复现 C:前后版本回归
详见 §6.4。脆弱版与修复版使用相同的 mock 栈、脱敏向量和请求序列,对比日志输出与功能结果。
5. 影响与可利用性边界
5.1 按能力拆分后的结论
结论 | 证据 | 限制 |
| 端到端日志样本 + | — |
能读日志的主体可获得期望认证响应值 |
| 需具备日志读取权限 |
| 本地基准 | CPU 频率未固定;并非跨平台保证;不能外推至远程场景 |
16 字节 | 本地基准未支持该结论 | 修正基准中约 2.6–2.9 ns/op,未出现逐字节单调趋势;实现与平台相关 |
经远程 HTTP/SBI 的实用定时恢复 | 尚无端到端证据 | advisory 的结论为 “SIGNAL NOT CLEAR”;本文未进行严格的远程统计 |
持有 | 同一 | 需要日志读取能力(或其他 |
由上项形成跨主体认证绕过 | 仅能由实现行为推断,尚无端到端验证 | AUSF 层没有一次性消费门控;但“日志读取者”与“可代表 AMF 调用 SBI 的主体”能否合并,以及 UDM 或部署策略是否会阻断,均不能仅凭 mock 环境判断 |
| 脆弱版 | 级别为 TRACE,默认 |
5.2 按角色拆分的实际影响
攻击者角色 | 能读到什么 | 还能做什么 | 结论 |
远程 SBI 调用者(有/无 OAuth) | 自身请求的响应;成功/失败粗粒度差异 | 触发认证、提交 | 无法仅凭远程调用直接读到 |
AUSF 节点/容器本地读取者 | INFO 日志中 | 若同时具备本机进程/网络访问,可提交确认 | 认证材料暴露已证实;AUSF 层的成功确认行为可由源码及 mock 序列证实 |
日志管线/SIEM 读取者 | 采集到的 | 通常没有 SBI 调用通道 | 认证材料已经暴露;若同时具备 SBI 调用能力,则可能进一步影响认证 |
低噪声侧信道观察者 | 比较器级耗时 | 对候选值做统计区分 |
|
5.3 关键判断
- 已证实的直接影响是认证材料暴露:
XRES*离开进程内的机密域,进入可由多个主体读取的日志。CVSS 的 LOW 级别机密性影响主要来自这条链。 - AUSF 层已证实的条件化影响:
ue_authentication.go:365的日志映射可帮助关联authCtxId;5G-AKA 确认函数既不检查AuthStatus,也不删除上下文。本地测试证明,同一上下文在一次失败后,仍可凭正确的XRES*获得AUTHENTICATION_SUCCESS和Kseaf。因此,不能假设上下文会在首次确认后自动失效。 - 跨主体认证绕过尚未证实:获得
XRES*并不等于获得 AMF/SEAF 的 SBI 身份。攻击者还必须同时具备日志读取能力,以及 SBI 调用授权或网络路径。本文也未验证真实 UDM 和部署策略是否接受延迟或重复的成功认证事件,因此不能将跨主体影响描述为已完成的攻击链。 - 不能夸大远程定时结果:advisory 对 HTTP/SBI 的结论是 “SIGNAL NOT CLEAR”。这既不能证明在所有条件下均不可利用,也不能证明远程利用已经成立。本文不会将本地 32 字符
EqualFold的信号直接外推为网络预言机。
6. 补丁与回归分析
6.1 修复 diff
@@ -1,9 +1,9 @@
package processor
import (
- "bytes"
"crypto/hmac"
"crypto/sha256"
+ "crypto/subtle"
"encoding/base64"
"encoding/binary"
"encoding/hex"
@@ -132,10 +132,10 @@
XRES := ausfCurrentContext.XRES
RES := hex.EncodeToString(decodeEapAkaPrimePkt.Attributes[ausf_context.AT_RES_ATTRIBUTE].Value)
- if !bytes.Equal(MAC, XMAC) {
+ if !constantTimeEqual(MAC, XMAC) {
eapOK = false
eapErrStr = "EAP-AKA' integrity check fail"
- } else if XRES == RES {
+ } else if constantTimeHexEqual(XRES, RES) {
logger.AuthELog.Infoln("Correct RES value, EAP-AKA' auth succeed")
eapSession.KSeaf = ausfCurrentContext.Kseaf
eapSession.Supi = currentSupi
@@ -391,7 +391,6 @@
}
hxresStarAll := sha256.Sum256(hxresStarBytes)
hxresStar := hex.EncodeToString(hxresStarAll[16:]) // last 128 bits
- logger.Auth5gAkaLog.Infof("XresStar = %x\n", authInfoResult.AuthenticationVector.XresStar)
// Derive Kseaf from Kausf
Kausf := authInfoResult.AuthenticationVector.Kausf
@@ -575,8 +574,7 @@
servingNetworkName := ausfCurrentContext.ServingNetworkName
// Compare the received RES* with the stored XRES*
- logger.Auth5gAkaLog.Infof("res*: %x\nXres*: %x\n", updateConfirmationData.ResStar, ausfCurrentContext.XresStar)
- if strings.EqualFold(updateConfirmationData.ResStar, ausfCurrentContext.XresStar) {
+ if constantTimeHexEqual(updateConfirmationData.ResStar, ausfCurrentContext.XresStar) {
ausfCurrentContext.AuthStatus = models.AusfUeAuthenticationAuthResult_SUCCESS
confirmDataRsp.AuthResult = models.AusfUeAuthenticationAuthResult_SUCCESS
success = true
@@ -603,6 +601,24 @@
}
c.JSON(http.StatusOK, confirmDataRsp)
+}
+
+func constantTimeHexEqual(a, b string) bool {
+ aBytes, err := hex.DecodeString(a)
+ if err != nil {
+ return false
+ }
+
+ bBytes, err := hex.DecodeString(b)
+ if err != nil {
+ return false
+ }
+
+ return constantTimeEqual(aBytes, bBytes)
+}
+
+func constantTimeEqual(a, b []byte) bool {
+ return len(a) == len(b) && subtle.ConstantTimeCompare(a, b) == 1
}
func KDF5gAka(param ...string) hash.Hash {修复版源码位于
ausf-fixed/src/,对应 修复提交中的源码。
6.2 为什么补丁能切断已定位的漏洞链
- 删除两条 INFO 日志:直接移除已定位的
XresStarINFO sink。SUPI/SUCI、AUTS 等另行发现的日志隐私问题不在本次修复范围内(见 §7.3)。 - 三处认证比较改用
subtle.ConstantTimeCompare:对于合法且等长的已解码认证值,比较时间不再取决于首个失配位置。 constantTimeHexEqual先进行 hex 解码:比较前统一编码语义,避免strings.EqualFold的 Unicode 大小写折叠和前缀短路。- helper 不是端到端的常数时间解析器:
hex.DecodeString遇到非法输入会提前报错,len(a)==len(b)也会提前返回。前一分支只取决于攻击者提交的a与受信任、且应为合法 hex 的b;后一分支会暴露长度。准确说,补丁保护的是合法、等长 hex 输入下的机密比较,而非任意输入。业务入口仍应校验协议允许的精确长度,避免 helper 将空字符串等“合法 hex、但非合法认证值”的输入判为相等。
这里采用的 API 语义可直接对照 Go 文档:crypto/subtle.ConstantTimeCompare 用于常数时间字节比较,crypto/hmac.Equal 提供 MAC 比较接口;作为对照,bytes.Equal 并不承诺常数时间行为。
6.3 补丁覆盖矩阵(本仓库视角)
Sink(脆弱版) | 修复动作 | 覆盖结论 |
| 删除 | 已覆盖 |
| 删除 | 已覆盖 |
| → | 对合法、等长 hex 值的失配位置泄露已覆盖 |
| → | 对等长 MAC 值的失配位置泄露已覆盖 |
| → | 对合法、等长 hex 值的失配位置泄露已覆盖 |
| 未删除 | 残留(TRACE 级别,运行暴露待验证) |
残留项(源码已确认,但尚未在运行时复现):修复版 ausf-fixed/src/internal/sbi/processor/ue_authentication.go:455 的 EAP-AKA' 分支仍保留 logger.AuthELog.Tracef("K_aut: %x", K_aut)。K_aut 是 EAP-AKA' 完整性密钥,属于认证材料,并在 eapAkaPrimePrf 派生后立即进入 TRACE 日志。
以下连续的修复版源码同时给出了 PRF 输入、K_aut 产生点、日志 sink 及后续写入上下文的操作,而非仅引用一条孤立的 Tracef:
identity := eapAkaPrimeIdentity
ikPrime := authInfoResult.AuthenticationVector.IkPrime
ckPrime := authInfoResult.AuthenticationVector.CkPrime
RAND := authInfoResult.AuthenticationVector.Rand
AUTN := authInfoResult.AuthenticationVector.Autn
XRES := authInfoResult.AuthenticationVector.Xres
ausfUeContext.XRES = XRES
ausfUeContext.Rand = authInfoResult.AuthenticationVector.Rand
_, K_aut, _, _, EMSK := eapAkaPrimePrf(ikPrime, ckPrime, identity)
logger.AuthELog.Tracef("K_aut: %x", K_aut)
ausfUeContext.K_aut = hex.EncodeToString(K_aut)
Kausf := EMSK[0:32]
ausfUeContext.Kausf = hex.EncodeToString(Kausf)
P0 := []byte(snName)
Kseaf, err := ueauth.GetKDFValue(Kausf, ueauth.FC_FOR_KSEAF_DERIVATION, P0, ueauth.KDFLen(P0))
if err != nil {
logger.AuthELog.Errorf("GetKDFValue failed: %+v", err)
}
ausfUeContext.Kseaf = hex.EncodeToString(Kseaf)
var eapPkt radius.EapPacket
eapPkt.Code = radius.EapCode(1)默认级别的判断则直接来自本仓库配置:
logger:
enable: true
level: info
reportCaller: false- 日志级别为 TRACE(logrus
TraceLevel=6),而本仓库ausfcfg.yaml为logger.level: info(logrusInfoLevel=4),因此默认不向 stdout/采集输出该行。 - 运行时暴露面待验证:仓库中的 mock UDM 只返回
5G_AKA向量,无法触发 EAP-AKA' 路径。本文未在运行日志中实际观察到K_aut,因此仅将其视为源码确认的日志 sink,而非“已复现的 TRACE 泄露”。
6.4 同条件版本回归
修复版使用相同的 mock NRF/UDM、脱敏向量和请求序列,仅将 AUSF 切换至固定 revision,并独立绑定宿主机的 19100/19101/19102 端口和 core-fixed bridge 网络。两个栈可并排构建、运行和比较,不会复用容器或网络状态。
如需独立复现这一前后版本对照,可将下列配置保存为根目录的 docker-compose.fixed.yml。它与 §4.1 的脆弱版配置仅在 AUSF 构建目录、服务名称、端口和网络名称上不同,因此两个栈可以同时运行:
services:
nrf:
build:
context: ./mockcore
dockerfile: Dockerfile
image: cve-2026-55785-mockcore:1.0.0
container_name: cve-2026-55785-fixed-nrf
environment:
NRF_SELF_URL: "http://nrf:8000"
UDM_SELF_URL: "http://udm:8000"
ports:
- "${NRF_FIXED_HOST_PORT:-19101}:8000"
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8000/nnrf-disc/v1/nf-instances"]
interval: 5s
timeout: 3s
retries: 12
start_period: 2s
networks: [core-fixed]
udm:
build:
context: ./mockcore
dockerfile: Dockerfile
image: cve-2026-55785-mockcore:1.0.0
container_name: cve-2026-55785-fixed-udm
environment:
NRF_SELF_URL: "http://nrf:8000"
UDM_SELF_URL: "http://udm:8000"
ports:
- "${UDM_FIXED_HOST_PORT:-19102}:8000"
networks: [core-fixed]
ausf:
build:
context: ./ausf-fixed
dockerfile: Dockerfile
image: cve-2026-55785-ausf-fixed:1.0.0
container_name: cve-2026-55785-fixed-ausf
depends_on:
nrf:
condition: service_healthy
ports:
- "${AUSF_FIXED_HOST_PORT:-19100}:8000"
networks: [core-fixed]
networks:
core-fixed:
driver: bridge
name: cve-2026-55785-core-fixeddocker compose -f docker-compose.fixed.yml up -d --build
AUSF_URL=http://127.0.0.1:19100
BASE="$AUSF_URL/nausf-auth/v1"
SUPI=imsi-2089300007487
curl -i -X POST "$BASE/ue-authentications" -H 'Content-Type: application/json' \
-d '{"supiOrSuci":"imsi-2089300007487","servingNetworkName":"5G:mnc070.mcc208.3gppnetwork.org"}'
curl -i -X PUT "$BASE/ue-authentications/$SUPI/5g-aka-confirmation" -H 'Content-Type: application/json' \
-d '{"resStar":"00000000000000000000000000000000"}'
curl -i -X PUT "$BASE/ue-authentications/$SUPI/5g-aka-confirmation" -H 'Content-Type: application/json' \
-d '{"resStar":"0123456789abcdef0123456789abcdef"}'
test -z "$(docker compose -f docker-compose.fixed.yml logs ausf | grep -E 'XresStar|Xres\*|res\*')"断言 | 脆弱版( | 修复版( |
|
|
|
错误 |
|
|
正确 |
|
|
日志含 | 是(§4.1) | 否(grep 无命中) |
UDM | 3 | 3 |
- 脆弱版的逐请求和日志证据见 §4.1。修复版的同条件运行记录如下:
=====================================================================
CVE-2026-55785 regression: fixed AUSF XRES* log check
=====================================================================
AUSF_URL = http://host.docker.internal:19100
SUPI = imsi-2089300007487
[*] Fixed AUSF is up.
[1/3] POST /ue-authentications (5G-AKA vector generation)
HTTP/1.1 201 Created
Location: http://ausf:8000/nausf-auth/v1/ue-authentications/imsi-2089300007487
{"authType":"5G_AKA","5gAuthData":{"rand":"b8a6c1d2e3f405162738495a6b7c8d9e","hxresStar":"32fce32908072a0d3b931066ea187199","autn":"5449ab1c9c91f9f60000000000000000"},"_links":{"5g-aka":[{"href":"http://ausf:8000/nausf-auth/v1/ue-authentications/imsi-2089300007487/5g-aka-confirmation"}]},"servingNetworkName":"5G:mnc070.mcc208.3gppnetwork.org"}
[2/3] PUT .../5g-aka-confirmation (WRONG RES*)
HTTP/1.1 200 OK
{"authResult":"AUTHENTICATION_FAILURE"}
[3/3] PUT .../5g-aka-confirmation (CORRECT RES*)
HTTP/1.1 200 OK
{"authResult":"AUTHENTICATION_SUCCESS","supi":"imsi-2089300007487","kseaf":"e9e4cd8fa1e5c8bc4afd343a41bcc1f4a70a9fafdd8456245d91a1e4046ce229"}
[*] Inspecting fixed AUSF logs for leaked secret fields...
[*] No 'XresStar' / 'Xres*' / 'res*' lines found in fixed AUSF logs.
PASS: fixed AUSF keeps the same 5G-AKA auth results (failure + success)
and no longer writes the expected-response value to the INFO log.下图为修复版在容器中的同条件回归运行,以及 grep 日志得到计数 0(XresStar/res*/Xres* 已消失):
- 已经证实:删除两条 INFO sink 后,相同的 5G-AKA 输入不再生成
XresStar/res*/Xres*日志,认证结果和 UDM 通知次数保持一致,未观察到功能语义回归。 - 尚未覆盖:EAP-AKA' 的正、负向用例(mock UDM 不提供 EAP 向量,无法生成合法的 EAP-AKA' challenge),以及 TRACE 级别下
K_aut的运行验证。这两项仍标记为待验证。
实验结束后,清理步骤实际先停止并删除两个 compose 栈(包括匿名卷及孤立容器),再删除本地
构建的 AUSF、修复版 AUSF、mockcore 和基准镜像:
docker compose down --volumes --remove-orphans || true
docker compose -f docker-compose.fixed.yml down --volumes --remove-orphans || true
docker rmi -f cve-2026-55785-ausf:1.0.0 \
cve-2026-55785-ausf-fixed:1.0.0 cve-2026-55785-mockcore:1.0.0 \
cve-2026-55785-timing-bench cve-2026-55785-bench-builder:corrected || true6.5 constantTimeHexEqual 的行为语义(边界输入)
以下结论直接由修复版 helper 代码推导:
输入 |
|
|
|
|
|
大小写混合等值( |
|
|
非 hex 字符相同( |
|
|
非法 hex / 奇数字符数 | 可能 true/短路 |
|
长度不等 | 按长度短路 |
|
设计含义:
- 非法输入统一返回
false,这相当于将“任意字符串相等”收紧为“合法 hex 字节相等”,通常只会拒绝原本就不合法的请求。 ("", "")仍返回true,说明 helper 本身不代替协议层的非空和精确长度校验;在正常认证上下文中,期望值应由 UDM/派生流程填充。hex.DecodeString的报错时间受非法字符位置和输入长度影响,所以它不是面向任意格式输入的恒定时间解析器。由于b是 AUSF 保存的受信任合法值,该分支的执行时间不会因为机密值的首个失配位置而变化,但结论必须带上这一前提。len(a)==len(b)会让长度相等性变得可观测。固定 16 字节的AT_MAC和 32 个 hex 字符的 5G-AKAXRES*属于公开协议参数;EAP 的AT_RES长度可在 4–16 字节间变化,因此应单独判断长度是否公开,不能笼统地将所有值都视为固定 16 字节。
7. 变体检索、检测与缓解
7.1 范围声明
变体搜索仅覆盖当前 AUSF revision(ausf/src @ bfc4a100…)和修复版(ausf-fixed/src @ 7a5a4aa1…)的关键文件,未扫描 free5GC 的其他 NF。下文的“全仓”仅指这两个 AUSF revision,不能据此推断 free5GC 的所有 NF 均已完成排查。
7.2 审计规则
模式 | 查询(概化) | 判定标准 |
P1 秘密值 + 短路比较 |
| 非恒定时间比较 → 可疑 |
P2 秘密值 + 日志/格式化 sink |
| 敏感信息落日志 → 按级别分级 |
P3 秘密值派生/传播 |
| 用于确认生命周期与边界 |
7.3 命中表与人工复核
以下命令用于初筛脆弱版认证处理器;随后仍需逐项人工判断数据的机密性、可控性及是否跨越信任边界:
F=ausf/src/internal/sbi/processor/ue_authentication.go
grep -nE 'XresStar|XRES|K_aut|Kausf|Kseaf|XMAC|AT_MAC|AT_RES|ResStar' "$F" | head -n 16
grep -nE 'EqualFold|bytes[.]Equal|XRES == RES|Infof[(]|Tracef[(]|Warnf[(]' "$F" | head -n 16完整命中数分别为 57 与 36 行。下图是容器内真实运行的前 16 行输出;命中本身只用于缩小复核范围,不等于漏洞结论。
命中 | 位置 | 秘密性 | 攻击者可控性 | 边界 | 人工结论 |
|
| 是(XresStar) | 是(ResStar 完全可控) | 跨 SBI | 确认非常数时间比较(本 CVE 已覆盖) |
|
| 是(XMAC) | 是(MAC 可控) | 跨 SBI | 确认非常数时间比较(本 CVE 已覆盖) |
|
| 是(XRES) | 是(RES 可控) | 跨 SBI(被 AT_MAC 门控) | 确认非常数时间比较(本 CVE 已覆盖) |
|
| 是 | — | 跨日志(INFO) | 已直接复现 CWE-532 |
|
| 是 | 部分 | 跨日志(INFO) | 已直接复现 CWE-532 |
| 脆弱版 | 是 | — | 跨日志(TRACE) | 源码确认审计残留;运行暴露待验证 |
|
| 不是密钥,但包含 SUPI/SUCI 永久或隐私标识符,同时提供 | 是(选择器) | 跨日志(INFO) | 存在隐私和利用链关联风险;不属于本 CVE 披露的 |
|
| AUTS 与订户/挑战材料 | 部分 | 跨日志(WARN) | 范围外日志审计发现;未证明构成本 CVE 的认证秘密泄露,但不应视为无敏感性 |
|
| 否(仅 error 文本) | — | 跨日志 | 排除(不打印密钥值) |
|
| 否(控制流文本) | — | 跨日志 | 排除(无值) |
7.4 结论纪律
- 搜索命中只表示该位置需要人工复核,不等于漏洞。
- 在已复核的核心命中中,三处非常数时间比较属于 CVE 明确披露的对象;两处
XresStarINFO sink 已由补丁删除;K_autTRACE sink 是源码确认的残留项,但尚未在运行时复现。SUPI/SUCI、AUTS 等范围外日志项即使不是认证密钥,仍可能带来隐私风险。 - 本文中的“已确认”仅表示该模式存在,且源码或调用链足以解释其如何到达边界;并不自动代表可利用。
7.5 检测规则
运行侧可使用 grep -E 'XresStar|Xres\*|res\*|K_aut|SuciSupiPair|Auts:' 搜索 AUSF 日志。命中后仍应依照图中的类别人工复核,不能仅凭关键词直接判定漏洞。
7.6 缓解建议
- 升级至包含
7a5a4aa1…的v1.4.5,或直接应用该提交。GHSA 的 patched-version 元数据尚未同步,版本判断应以实际提交内容为准。 - 临时缓解:将日志级别提高到 WARN/ERROR,收紧日志文件和采集管线的访问权限,并在 SIEM 侧对
XresStar/Xres*/res*/AT_MAC/K_aut/SUPI/SUCI/AUTS做脱敏处理。 - 补充治理:升级后仍需审计 TRACE 日志,因为
K_autsink 没有随本次补丁删除;同时清理 SUPI/SUCI、AUTS 等范围外日志,并明确生产环境是否允许开启 TRACE。
8. 结论与审计启示
本次分析留下两条可复用的审计经验:
- 认证秘密不能进入日志:比较基准值一旦写入可持久化、可由多个主体读取的日志,机密边界便已被破坏。日志级别只能缩小暴露面,无法改变机密数据已经跨越边界的事实。
- API 权限边界和可观测性边界要一起审计:只看“谁能调用 SBI”,会漏掉“谁能读取日志”这条独立的权限轴(Capability A / B)。
subtle.ConstantTimeCompare或hmac.Equal对固定长度密钥材料提供的是等长输入下与失配位置无关的比较;长度分支仍然可见,可变长度值还需要明确的长度约束。
CVE-2026-55785 是一个低危但很有代表性的认证实现缺陷。它不涉及内存破坏;风险来自两条基础密码学工程规则同时失守:认证值的比较未采用常数时间实现,机密值也被写入普通日志。是否会进一步发展为跨主体越权,取决于日志读取能力能否与 AMF/SEAF 的 SBI 调用能力结合。
- CWE-532(日志泄露) 已通过端到端测试直接复现,也是 CVSS 机密性影响为 LOW 的主要来源。日志中虽是
%x编码,仍可无损还原完整XRES*。 - CWE-208/385(非常数时间比较) 的修正后本地微基准不支持统一的利用结论:32 字符的
strings.EqualFold耗时与失配位置明显相关,修复版constantTimeHexEqual未见这一趋势;16 字节bytes.Equal经runtime.memequal执行,实测约 2.6–2.9 ns/op,未呈现逐字节单调趋势。这说明,不能将已被优化掉的旧基准或某一平台的实现细节外推为通用的逐字节预言机。远程实用定时恢复仍未证实;该问题更适合作为防御性加固依据,而非已完成的 exploit。 - 补丁覆盖具有针对性:三处比较和两条
XRES*INFO 日志均已处理。对合法、等长输入,比较时间不再随失配位置变化;但 helper 的解析错误和长度分支并非端到端常数时间。版本回归证明,相同的 5G-AKA 输入在新版中不再产生XresStar/res*/Xres*日志,同时认证结果与 UDM 通知次数保持一致。EAP-AKA' 的K_autTRACE 日志,以及 SUPI/SUCI/AUTS 等其他日志风险,仍需另行治理。 - 影响边界同样明确:源码与实验已经证明,认证材料和
authCtxId关联信息会进入日志;也证明同一 5G-AKA 上下文在一次失败后,仍可凭正确的XRES*完成确认。跨主体认证绕过仍依赖日志读取能力、SBI 授权或网络路径,以及真实 UDM 和部署策略;本文未完成端到端验证,因此继续标为需要额外研究。
审计认证代码时,看到机密值被当作普通字符串比较或直接写入日志,不能只看是否越界、是否做了输入校验。更关键的是:比较是否为常数时间?机密是否仍被限制在应有的信任域内? CVE-2026-55785 的问题正出在这两个位置。