0. 核心结论

free5GC AUSF 在 5G-AKA / EAP-AKA' 认证流程中存在两类彼此独立的缺陷:

  1. CWE-532(敏感信息写入日志):向量生成阶段(internal/sbi/processor/ue_authentication.go:394)和 5G-AKA 比较前(internal/sbi/processor/ue_authentication.go:578)均以 INFO 级别将期望认证响应值 XRES* 以可逆编码形式写入应用日志。
  2. 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-fp46-6vfw-gc9c、MITRE、NVD

受影响组件

github.com/free5gc/ausf(AUSF 认证服务功能)

GHSA 公告、Issue #1067

受影响版本

< v1.4.5(含 v1.4.4 与 2026-05 main 分支 bfc4a100…)

GHSA 公告、仓库提交记录

修复交付

修复提交已包含于 v1.4.5(发布 2026-06-30);GHSA 的 patched versions 字段仍显示 None

GitHub PR/Release API 与发布产物交叉核对

修复 PR

#63(2026-06-22 合并,作者 wiwi878)

GitHub PR API

CVSS 3.1

3.7(LOW),CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N

GHSA 公告、NVD API

CWE

CWE-208 / CWE-385 / CWE-532

GHSA 公告、NVD API

漏洞模块

internal/sbi/processor/ue_authentication.go

脆弱版固定源码

经 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 审计与测试环境

项

值

审计源码

ausf/src/(随仓库交付,构建不依赖 git 拉取;ausf/src/COMMIT = bfc4a100…)

修复源码

ausf-fixed/src/(由固定 commit 的 codeload tarball 落地,单文件 diff 与 raw.githubusercontent.com 核对一致)

构建镜像

golang:1.26.3-alpine,CGO_ENABLED=0;运行镜像 alpine:3.20

mock NRF/UDM

mockcore/(最小 SBI + h2c),golang:1.26.3-alpine

编排

docker-compose.yml(脆弱版:18000/18001/18002)、docker-compose.fixed.yml(修复版:19100/19101/19102)

运行时复现/截图环境

一次性 Linux 容器(linux/arm64):go1.26.5、Docker CLI 29.7.2、Compose v5.5.0,运行于 Apple M2(Docker Desktop);命令通过 Docker socket 驱动同一 Docker Desktop 环境

静态分析环境(CodeQL)

macOS (darwin/arm64),CodeQL CLI 2.26.1 + codeql/go-all@7.1.0;Go 数据库为平台相关产物,未在容器中重建

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 安全不变量(本文的分析基线)

  1. 机密性不变量:XRES*(5G-AKA)、XRES / K_aut(EAP-AKA')均为归属网络侧认证材料,只能在 AUSF 进程内按需使用,不得进入可被多个主体读取的普通日志。
  2. 常数时间比较不变量:比较“攻击者可控值与机密基准值”时,等长输入的执行时间不应取决于首个失配位置。
  3. 上下文绑定与消费不变量:认证向量与上下文应按 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

POST /nausf-auth/v1/ue-authentications

supiOrSuci、servingNetworkName

SBI 调用方可提供;需通过 SUPI/SUCI 与 serving-network 检查,且 UDM 接受

E2

PUT /nausf-auth/v1/ue-authentications/{authCtxId}/5g-aka-confirmation

resStar

需持有已建立的 authCtxId;resStar 无业务格式/长度校验

E3

POST /nausf-auth/v1/ue-authentications/{authCtxId}/eap-session

eapPayload(base64 EAP 包)

需 base64/EAP/属性结构解析通过;AT_MAC/AT_RES 值内容不受限

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 调用者

触发认证、提交 resStar/eapPayload;受 RouterAuthorizationCheck 约束

不自动等于能读取 AUSF 日志

Capability B:日志读取者(本地文件、sidecar、采集器、SIEM、被攻陷的容器或进程)

直接读取 XRES*;还可从 ue_authentication.go:365 的 INFO 日志取得 supiOrSuci → SUPI 映射,其中 supiOrSuci 就是确认 URI 中的 authCtxId

不必然具备 AUSF SBI 调用能力;但不应把 authCtxId 关联视为独立且困难的额外前置条件

授权与网络前提:

  • 每次请求都经过 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)

变量

类型

来源

赋值位置

业务校验

最终用途

updateConfirmationData.ResStar

string

HTTP JSON resStar

internal/sbi/api_ueauthentication.go:196 的 Deserialize

无

EqualFold 第 1 个实参 + Infof 第 2 个实参

authInfoResult.AuthenticationVector.XresStar

string

UDM 响应

internal/sbi/processor/ue_authentication.go:334 的 GenerateAuthDataApi 返回后

无

Infof(ue_authentication.go:394)+ 写入上下文(ue_authentication.go:427)

ausfUeContext.XresStar

string

上者写入

internal/sbi/processor/ue_authentication.go:427

无

日志(ue_authentication.go:578)+ 比较基准(ue_authentication.go:579)

MAC / RES(EAP)

[]byte / string

攻击者 eapPayload 经 base64→gopacket→decodeEapAkaPrime

internal/sbi/processor/ue_authentication.go:131 / ue_authentication.go:133

仅解析边界检查

bytes.Equal(ue_authentication.go:135)/ ==(ue_authentication.go:138)

XMAC / XRES / K_aut(EAP)

[]byte / string

UDM 向量 + AUSF 派生

internal/sbi/processor/ue_authentication.go:130 / ue_authentication.go:132 / ue_authentication.go:455

无

比较基准 / 完整性密钥(K_aut 还进 TRACE 日志)

编码与类型说明:问题不在数据长度,而在于如何进行相等性比较,以及机密值是否被写入日志。%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
}


阶段

位置

行为

创建

internal/sbi/processor/ue_authentication.go:359

NewAusfUeContext(ueid),字段为零值

入池

internal/sbi/processor/ue_authentication.go:363

AddAusfUeContextToPool → UePool.Store(SUPI, ausfUeContext)(存储指针)

建映射

internal/sbi/processor/ue_authentication.go:366

AddSuciSupiPairToMap(supiOrSuci, ueid)

字段填充

internal/sbi/processor/ue_authentication.go:427(5G)/ue_authentication.go:451(EAP)

ausfUeContext.XresStar/XRES = ...

读取

internal/sbi/processor/ue_authentication.go:574(5G)/ue_authentication.go:70(EAP)

GetAusfUeContext(currentSupi) 取回同一指针

删除/过期/TTL

未发现

全仓未见 UePool/suciSupiMap 的 Delete/Range 删除逻辑;HTTPDelete5gAkaAuthenticationResult/HTTPDeleteEapAuthenticationResult 返回 501(api_ueauthentication.go:214-220)

5G-AKA 确认状态门控

未发现

internal/sbi/processor/ue_authentication.go:550–574 只检查映射/上下文存在;ue_authentication.go:579 直接比较并可将既有 FAILURE 或 SUCCESS 改写为 SUCCESS,未先检查 AuthStatus

仓库虽然注册了删除路由,但两个与本文相关的 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 低 → 高

趋势

strings.EqualFold(脆弱 5G-AKA)

32 hex 字符

prefix 0/8/16/24/31:~1.93 / 5.72 / 9.45 / 13.22 / 16.54

首个失配位置越后,总体耗时越高

constantTimeHexEqual(修复版语义)

32 hex 字符

代表位置约 ~55.7–56.1

未见随失配位置的系统变化

bytes.Equal(脆弱版 EAP AT_MAC)

16 字节

prefix 0/8/15/16:~2.66 / 2.74 / 2.63 / 2.91

实现呈现块级/完全相等路径差异,无逐字节单调趋势

subtle.ConstantTimeCompare

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 按能力拆分后的结论


结论

证据

限制

XRES* 以可逆编码形式写入 INFO 日志

端到端日志样本 + internal/sbi/processor/ue_authentication.go:394 / ue_authentication.go:578 直接证明

—

能读日志的主体可获得期望认证响应值

Infof 无条件执行;%x 无损可逆

需具备日志读取权限

strings.EqualFold 耗时随失配位置变化

本地基准

CPU 频率未固定;并非跨平台保证;不能外推至远程场景

16 字节 bytes.Equal 的差异可作为本地预言机

本地基准未支持该结论

修正基准中约 2.6–2.9 ns/op,未出现逐字节单调趋势;实现与平台相关

经远程 HTTP/SBI 的实用定时恢复

尚无端到端证据

advisory 的结论为 “SIGNAL NOT CLEAR”;本文未进行严格的远程统计

持有 XRES* 后提交成功的 5G-AKA 确认

同一 authCtxId 在失败后提交正确值,返回成功及 Kseaf

需要日志读取能力(或其他 XRES* 来源)以及 SBI 调用授权/网络路径;真实 UDM 是否接受该事件须结合部署验证

由上项形成跨主体认证绕过

仅能由实现行为推断,尚无端到端验证

AUSF 层没有一次性消费门控;但“日志读取者”与“可代表 AMF 调用 SBI 的主体”能否合并,以及 UDM 或部署策略是否会阻断,均不能仅凭 mock 环境判断

K_aut 被写 TRACE 日志(源码确认的审计残留)

脆弱版 internal/sbi/processor/ue_authentication.go:456;修复版 ausf-fixed/src/internal/sbi/processor/ue_authentication.go:455

级别为 TRACE,默认 info 不输出;运行暴露面待验证

5.2 按角色拆分的实际影响

攻击者角色

能读到什么

还能做什么

结论

远程 SBI 调用者(有/无 OAuth)

自身请求的响应;成功/失败粗粒度差异

触发认证、提交 resStar/eapPayload

无法仅凭远程调用直接读到 XRES*;定时信号尚未证实可用

AUSF 节点/容器本地读取者

INFO 日志中 XRES* 与 authCtxId → SUPI 映射(已复现前者,源码确认后者)

若同时具备本机进程/网络访问,可提交确认

认证材料暴露已证实;AUSF 层的成功确认行为可由源码及 mock 序列证实

日志管线/SIEM 读取者

采集到的 XRES* 及可关联的 authCtxId

通常没有 SBI 调用通道

认证材料已经暴露;若同时具备 SBI 调用能力,则可能进一步影响认证

低噪声侧信道观察者

比较器级耗时

对候选值做统计区分

EqualFold 存在位置相关信号;可恢复性与远程可观测性均未证实

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 为什么补丁能切断已定位的漏洞链


  1. 删除两条 INFO 日志:直接移除已定位的 XresStar INFO sink。SUPI/SUCI、AUTS 等另行发现的日志隐私问题不在本次修复范围内(见 §7.3)。
  2. 三处认证比较改用 subtle.ConstantTimeCompare:对于合法且等长的已解码认证值,比较时间不再取决于首个失配位置。
  3. constantTimeHexEqual 先进行 hex 解码:比较前统一编码语义,避免 strings.EqualFold 的 Unicode 大小写折叠和前缀短路。
  4. 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(脆弱版)

修复动作

覆盖结论

ue_authentication.go:394 Infof("XresStar = %x")

删除

已覆盖

ue_authentication.go:578 Infof("res*/Xres*")

删除

已覆盖

ue_authentication.go:579 strings.EqualFold

→ constantTimeHexEqual

对合法、等长 hex 值的失配位置泄露已覆盖

ue_authentication.go:135 bytes.Equal

→ constantTimeEqual

对等长 MAC 值的失配位置泄露已覆盖

ue_authentication.go:138 XRES == RES

→ constantTimeHexEqual

对合法、等长 hex 值的失配位置泄露已覆盖

ue_authentication.go:456 Tracef("K_aut: %x")

未删除

残留(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(logrus InfoLevel=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-fixed
docker 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\*')"


断言

脆弱版(bfc4a100…)

修复版(7a5a4aa1…)

POST /ue-authentications

201 Created

201 Created

错误 resStar

AUTHENTICATION_FAILURE

AUTHENTICATION_FAILURE

正确 resStar

AUTHENTICATION_SUCCESS(kseaf=e9e4cd8f…)

AUTHENTICATION_SUCCESS(kseaf=e9e4cd8f…)

日志含 XresStar / res* / Xres*

是(§4.1)

否(grep 无命中)

UDM /auth-events 计数(1 失败 + 1 成功)

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 || true

6.5 constantTimeHexEqual 的行为语义(边界输入)

以下结论直接由修复版 helper 代码推导:

输入

strings.EqualFold(旧)

constantTimeHexEqual(新)

("", "")

true

true(空 hex 解码成功,等长 ConstantTimeCompare 返回 1)

大小写混合等值("0a" vs "0A")

true

true(hex 解码均得 0x0a)

非 hex 字符相同("zz" vs "zz")

true

false(DecodeString 报错后返回 false)

非法 hex / 奇数字符数

可能 true/短路

false

长度不等

按长度短路

len(a)==len(b) 短路,false

设计含义:

  • 非法输入统一返回 false,这相当于将“任意字符串相等”收紧为“合法 hex 字节相等”,通常只会拒绝原本就不合法的请求。
  • ("", "") 仍返回 true,说明 helper 本身不代替协议层的非空和精确长度校验;在正常认证上下文中,期望值应由 UDM/派生流程填充。
  • hex.DecodeString 的报错时间受非法字符位置和输入长度影响,所以它不是面向任意格式输入的恒定时间解析器。由于 b 是 AUSF 保存的受信任合法值,该分支的执行时间不会因为机密值的首个失配位置而变化,但结论必须带上这一前提。
  • len(a)==len(b) 会让长度相等性变得可观测。固定 16 字节的 AT_MAC 和 32 个 hex 字符的 5G-AKA XRES* 属于公开协议参数;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 秘密值 + 短路比较

secret ∈ {XresStar, XRES, K_aut, Kausf, Kseaf, XMAC, AT_MAC} 作为 bytes.Equal/strings.EqualFold/==/strings.Compare 实参

非恒定时间比较 → 可疑

P2 秘密值 + 日志/格式化 sink

secret 作为 logger.*f/log.*/fmt.* 实参

敏感信息落日志 → 按级别分级

P3 秘密值派生/传播

XresStar/XRES/K_aut 赋值与 UePool/suciSupiMap 存储

用于确认生命周期与边界

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 行输出;命中本身只用于缩小复核范围,不等于漏洞结论。


命中

位置

秘密性

攻击者可控性

边界

人工结论

strings.EqualFold

internal/sbi/processor/ue_authentication.go:579

是(XresStar)

是(ResStar 完全可控)

跨 SBI

确认非常数时间比较(本 CVE 已覆盖)

bytes.Equal

ue_authentication.go:135

是(XMAC)

是(MAC 可控)

跨 SBI

确认非常数时间比较(本 CVE 已覆盖)

XRES == RES

ue_authentication.go:138

是(XRES)

是(RES 可控)

跨 SBI(被 AT_MAC 门控)

确认非常数时间比较(本 CVE 已覆盖)

Infof("XresStar = %x")

ue_authentication.go:394

是

—

跨日志(INFO)

已直接复现 CWE-532

Infof("res*/Xres*")

ue_authentication.go:578

是

部分

跨日志(INFO)

已直接复现 CWE-532

Tracef("K_aut: %x")

脆弱版 ue_authentication.go:456;修复版 ausf-fixed/src/internal/sbi/processor/ue_authentication.go:455

是

—

跨日志(TRACE)

源码确认审计残留;运行暴露待验证

Infof("Add SuciSupiPair (%s, %s)")

ue_authentication.go:365

不是密钥,但包含 SUPI/SUCI 永久或隐私标识符,同时提供 authCtxId → SUPI 关联

是(选择器)

跨日志(INFO)

存在隐私和利用链关联风险;不属于本 CVE 披露的 XRES* sink

Warningln("Auts: ...")、SUPI、Rand

ue_authentication.go:281/288/295/299

AUTS 与订户/挑战材料

部分

跨日志(WARN)

范围外日志审计发现;未证明构成本 CVE 的认证秘密泄露,但不应视为无敏感性

Warnf("K_aut decode error: %+v")

ue_authentication.go:126

否(仅 error 文本)

—

跨日志

排除(不打印密钥值)

Tracef("Decoding AT_MAC") 等

ue_authentication.go:788/799

否(控制流文本)

—

跨日志

排除(无值)

7.4 结论纪律

  • 搜索命中只表示该位置需要人工复核,不等于漏洞。
  • 在已复核的核心命中中,三处非常数时间比较属于 CVE 明确披露的对象;两处 XresStar INFO sink 已由补丁删除;K_aut TRACE sink 是源码确认的残留项,但尚未在运行时复现。SUPI/SUCI、AUTS 等范围外日志项即使不是认证密钥,仍可能带来隐私风险。
  • 本文中的“已确认”仅表示该模式存在,且源码或调用链足以解释其如何到达边界;并不自动代表可利用。

7.5 检测规则


运行侧可使用 grep -E 'XresStar|Xres\*|res\*|K_aut|SuciSupiPair|Auts:' 搜索 AUSF 日志。命中后仍应依照图中的类别人工复核,不能仅凭关键词直接判定漏洞。

7.6 缓解建议

  1. 升级至包含 7a5a4aa1… 的 v1.4.5,或直接应用该提交。GHSA 的 patched-version 元数据尚未同步,版本判断应以实际提交内容为准。
  2. 临时缓解:将日志级别提高到 WARN/ERROR,收紧日志文件和采集管线的访问权限,并在 SIEM 侧对 XresStar/Xres*/res*/AT_MAC/K_aut/SUPI/SUCI/AUTS 做脱敏处理。
  3. 补充治理:升级后仍需审计 TRACE 日志,因为 K_aut sink 没有随本次补丁删除;同时清理 SUPI/SUCI、AUTS 等范围外日志,并明确生产环境是否允许开启 TRACE。

8. 结论与审计启示

本次分析留下两条可复用的审计经验:

  1. 认证秘密不能进入日志:比较基准值一旦写入可持久化、可由多个主体读取的日志,机密边界便已被破坏。日志级别只能缩小暴露面,无法改变机密数据已经跨越边界的事实。
  2. 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_aut TRACE 日志,以及 SUPI/SUCI/AUTS 等其他日志风险,仍需另行治理。
  • 影响边界同样明确:源码与实验已经证明,认证材料和 authCtxId 关联信息会进入日志;也证明同一 5G-AKA 上下文在一次失败后,仍可凭正确的 XRES* 完成确认。跨主体认证绕过仍依赖日志读取能力、SBI 授权或网络路径,以及真实 UDM 和部署策略;本文未完成端到端验证,因此继续标为需要额外研究。

审计认证代码时,看到机密值被当作普通字符串比较或直接写入日志,不能只看是否越界、是否做了输入校验。更关键的是:比较是否为常数时间?机密是否仍被限制在应有的信任域内? CVE-2026-55785 的问题正出在这两个位置。