OpenAI 解密 PSP 记录

2026-11-20 10:55 更新

如果已在自己的云存储中保留私有安全处理(PSP)记录,可以使用你控制的非对称密钥恢复记录内容。本指南适用于结合 PSP 的零数据保留(ZDR)。Private Retention with PSP 将记录保存在 OpenAI 管理的基础设施中,采用不同的访问方式。

拿到记录和原始密钥元数据后,云密钥管理服务负责解开恢复密封包,你的应用再用恢复的秘密在本地解密记录。私钥留在云端,解密本身无需调用 OpenAI API。

开始前

  • 启用 PSP 解密、连接存储并选择恢复密钥。操作见私有安全处理和配置非对称密钥。
  • 授权恢复应用读取存储对象,并使用对应记录原始 RSA-3072 恢复密钥进行解密。
  • 在仍需恢复这些记录时,保留原始注册、公钥和云密钥的确切版本。

密钥只能解密在该密钥的 PSP 解密已启用时写入的记录。已有记录不会自动转换。

解密记录

1. 读取记录

从云存储读取对象。如果外层使用企业密钥管理(EKM)封装,先按该记录原有的 EKM 配置解开外层。对于 OCI EKM,应用还需要对原始 AES 密钥拥有 KEY_DECRYPT,并且在操作中保留信封的密钥版本和作用域关联数据。

将内部内容解析为包含 protected_record 和 customer_access 的 JSON。附录列出完整格式。若 customer_access 为 null,该条记录无法使用 PSP 解密。

2. 选择原始密钥

用 customer_access.customer_key_id 在已保存的注册信息中查找云密钥及确切版本。必要时可用组织管理员 API 密钥调用 GET /v1/organization/external_keys/{customer_key_id} 查询注册,参见配置非对称密钥。

核对公钥指纹,并使用确切的云密钥版本。私钥不离开云密钥管理服务。

3. 解密恢复密封包

将 customer_access.recovery_secret 解码后交给云密钥管理服务,以 RSA-OAEP-SHA256 解密。OCI Vault 使用保管库的加密端点和 Decrypt 操作。

字段 值
keyId 原注册中的 key_ocid
keyVersionId 原注册中的确切 key_version_ocid
encryptionAlgorithm RSA_OAEP_SHA_256
ciphertext 对恢复秘密的原始字节使用标准 Base64 编码

记录包使用 base64url。先按 base64url 把 recovery_secret 解成字节,再为 OCI 编成标准 Base64。将 OCI 返回的 Base64 plaintext 解为字节,即得到下一步使用的恢复密封包。

恢复应用的 OCI 身份需要对原始 RSA 密钥拥有 KEY_DECRYPT。此权限与你为 OpenAI 配置的公钥读取权限分开管理。轮换后保持原版本可用。此 RSA 请求省略 associatedData。

4. 解密并验证内容

按附录示例验证密封包确实对应当前记录,再在本地解密。全部检查和 AES-GCM 认证都通过后,才可返回内容。

检查结果

成功时得到通过认证的 UTF-8 内容。请求记录含有 request_text 和用于判断截断的元数据。字段说明见附录末尾。

排查问题

结果 核对内容
customer_access 为 null 写入该记录时,恢复密钥对应的 PSP 解密未启用。事后选择密钥无法转换这条记录。
KMS 拒绝访问或密钥不可用 核对解密权限,确认原云密钥及版本可用。
指纹或绑定校验失败 确认记录、原注册信息和公钥相符。保持认证字段原样。
AES-GCM 认证失败 核对附录示例的入参。认证失败时丢弃输出。

相关指南

附录:格式与解密参考

本附录适用于记录包版本 1、受保护记录版本 v4。以下本地示例不依赖 OpenAI SDK。

记录包格式

内部记录包为 UTF-8 JSON。尖括号内为占位值。

{
  "bundle_version": 1,
  "protected_record": {
    "version": "v4",
    "algorithm": "HPKE-v1-DHKEM_P256_HKDF_SHA256-EXPORT_ONLY-AES256_GCM",
    "scope": "global",
    "key_thumbprint": "<runtime public-key thumbprint>",
    "expires_at": "2026-11-20",
    "content_id": "<content ID>",
    "encrypted_dek": "<E: base64url P-256 public point>",
    "safety_review_runtime_public_key": "<R: base64url P-256 public point>",
    "nonce": "<base64url 12-byte nonce>",
    "encrypted_cot": ["<opaque encrypted CoT string>"],
    "ciphertext": "<base64url ciphertext followed by GCM tag>"
  },
  "customer_access": {
    "version": 1,
    "algorithm": "RSA-OAEP-256",
    "customer_key_id": "<original registration ID>",
    "customer_public_key_fingerprint": "<RSA public-key fingerprint>",
    "recovery_secret": "<base64url RSA ciphertext>"
  }
}

encrypted_cot 包含另行加密的思维链内容,数组可能为空。客户恢复密钥始终无法读取这些密文。

解密示例

调用示例前,先解开独立的 EKM 外层(如存在),并在云端用原始密钥解密恢复密封包。示例会依次校验密钥指纹、密封包绑定、恢复的标量及运行时公钥指纹,然后认证并解密负载。

  • Python:安装 pyhpke、cryptography 和 rfc8785。
  • Go:安装 github.com/cyberphone/json-canonicalization/go/src/webpki.org/jsoncanonicalizer。完整程序用 Go 的加密包处理 P-256、HKDF 和 AES-GCM。命令从标准输入读取含 bundle、capsule、key_id、public_key 的 JSON 对象,其中 capsule 使用标准 Base64。
  • Ruby:安装 hpke 和 json-canonicalization,并准备 Ruby 的 OpenSSL 绑定。

将四项值传给 recover_record(Go 为 recoverRecord)。

  • bundle_json:内部记录包的 UTF-8 JSON 字节。
  • capsule:云密钥管理服务解出的密封包字节。
  • original_key_id:步骤 2 对应的原始密钥注册 ID。
  • original_public_key_pem:该版本 RSA 公钥的 PEM 字节。

所有检查通过后,函数返回 UTF-8 字符串。任一检查失败都会终止恢复。

import base64
import hashlib
import hmac
import json

import rfc8785
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec, rsa
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from pyhpke import AEADId, CipherSuite, KDFId, KEMId, KEMKey, KEMKeyPair


def recover_record(bundle_json, capsule, original_key_id, original_public_key_pem):
    """Return plaintext from exact inner bundle bytes and a decrypted capsule.

    Use the documented schema and trusted original key ID/RSA public PEM.
    No cloud calls occur here. The RSA private key stays in the cloud.
    """
    record, access, runtime, nonce, ciphertext = validate_bundle(
        bundle_json, original_key_id, original_public_key_pem
    )
    e = recover_scalar(record, access, capsule)

    ephemeral = ec.derive_private_key(e, ec.SECP256R1())
    pair = KEMKeyPair(
        KEMKey.from_pyca_cryptography_key(ephemeral),
        KEMKey.from_pyca_cryptography_key(ephemeral.public_key()),
    )
    suite = CipherSuite.new(
        KEMId.DHKEM_P256_HKDF_SHA256, KDFId.HKDF_SHA256, AEADId.EXPORT_ONLY
    )
    enc, sender = suite.create_sender_context(
        KEMKey.from_pyca_cryptography_key(runtime),
        info=b"OpenAI-PSP-v4/HPKE-export",
        eks=pair,
    )
    require(enc == decode64(record["encrypted_dek"]), "Wrong recovered scalar")
    aad = rfc8785.dumps({k: v for k, v in record.items() if k != "ciphertext"})
    key = sender.export(b"OpenAI-PSP-v4/payload-key" + hashlib.sha256(aad).digest(), 32)
    return AESGCM(key).decrypt(nonce, ciphertext, aad).decode("utf-8")


def validate_bundle(bundle_json, original_key_id, original_public_key_pem):
    bundle = json.loads(bundle_json.decode("utf-8"), object_pairs_hook=unique_object)
    require(
        type(bundle["bundle_version"]) is int and bundle["bundle_version"] == 1,
        "Unsupported bundle version",
    )
    record, access = bundle["protected_record"], bundle["customer_access"]
    require(access is not None, "Customer recovery is unavailable")
    require(
        record["version"] == "v4"
        and record["algorithm"]
        == "HPKE-v1-DHKEM_P256_HKDF_SHA256-EXPORT_ONLY-AES256_GCM",
        "Unsupported record",
    )
    require(
        type(access["version"]) is int
        and access["version"] == 1
        and access["algorithm"] == "RSA-OAEP-256",
        "Unsupported recovery capsule",
    )
    require(access["customer_key_id"] == original_key_id, "Wrong key registration")
    require(len(decode64(access["recovery_secret"])) == 384, "Wrong RSA length")

    public_key = serialization.load_pem_public_key(original_public_key_pem)
    require(isinstance(public_key, rsa.RSAPublicKey), "Expected an RSA public key")
    require(public_key.key_size == 3072, "Expected RSA-3072")
    spki = public_key.public_bytes(
        serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo
    )
    fingerprint = decode64(access["customer_public_key_fingerprint"])
    require(
        hmac.compare_digest(fingerprint, hashlib.sha256(spki).digest()), "Wrong key"
    )
    runtime = point(record["safety_review_runtime_public_key"])
    coordinates = runtime.public_numbers()
    jwk = {
        "crv": "P-256",
        "kty": "EC",
        "x": b64url(coordinates.x.to_bytes(32, "big")),
        "y": b64url(coordinates.y.to_bytes(32, "big")),
    }
    thumbprint = b64url(hashlib.sha256(rfc8785.dumps(jwk)).digest())
    require(record["key_thumbprint"] == thumbprint, "Wrong runtime key")
    nonce, ciphertext = decode64(record["nonce"]), decode64(record["ciphertext"])
    require(len(nonce) == 12 and len(ciphertext) >= 16, "Invalid AES-GCM encoding")
    return record, access, runtime, nonce, ciphertext


def recover_scalar(record, access, capsule):
    header = {k: v for k, v in access.items() if k != "recovery_secret"}
    binding_input = {
        "purpose": "OpenAI-PSP-v4/customer-recovery-binding",
        "bundle_version": 1,
        "record": record,
        "recovery_header": header,
    }
    binding = hashlib.sha256(rfc8785.dumps(binding_input)).digest()
    require(
        isinstance(capsule, bytes)
        and len(capsule) == 72
        and capsule[:8] == b"PSPv4\x00\x00\x01"
        and hmac.compare_digest(capsule[40:], binding),
        "Invalid recovery capsule binding",
    )
    e = int.from_bytes(capsule[8:40], "big")
    order = 0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
    require(1 <= e < order, "Invalid P-256 private scalar")
    return e


def require(condition, message):
    if not condition:
        raise ValueError(message)


def unique_object(pairs):
    require(len(pairs) == len(dict(pairs)), "Duplicate JSON field")
    return dict(pairs)


def b64url(data):
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")


def decode64(value):
    # 用 -len(value) % 4 计算缺少的等号填充,使长度成为 4 的倍数。
    # 例如长度为 10 时需要补上两个等号。
    data = base64.b64decode(
        value + "=" * (-len(value) % 4), altchars=b"-_", validate=True
    )
    require(b64url(data) == value, "Noncanonical base64url")
    return data


def point(value):
    encoded = decode64(value)
    require(len(encoded) == 65 and encoded[0] == 4, "Invalid P-256 encoding")
    return ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP256R1(), encoded)

// 使用解密后的密封包与原始可信注册信息恢复内部记录包。
// 使用原始记录包字节,RSA 私钥继续留在云端。
func recoverRecord(bundleJSON, capsule []byte, originalKeyID string, publicPEM []byte) (string, error) {
    // 规范化先拒绝重复字段和无效 Unicode,再进行解码。
    if _, err := jsoncanonicalizer.Transform(bundleJSON); err != nil {
        return "", err
    }
    decoder := json.NewDecoder(bytes.NewReader(bundleJSON))
    decoder.UseNumber()
    var bundle map[string]any
    if err := decoder.Decode(&bundle); err != nil {
        return "", err
    }
    if bundle["bundle_version"] != json.Number("1") {
        return "", fmt.Errorf("unsupported bundle version")
    }
    record, ok := bundle["protected_record"].(map[string]any)
    if !ok {
        return "", fmt.Errorf("invalid protected record")
    }
    access, ok := bundle["customer_access"].(map[string]any)
    if !ok {
        return "", fmt.Errorf("customer recovery is unavailable")
    }
    if record["version"] != "v4" || record["algorithm"] != "HPKE-v1-DHKEM_P256_HKDF_SHA256-EXPORT_ONLY-AES256_GCM" || access["version"] != json.Number("1") || access["algorithm"] != "RSA-OAEP-256" || access["customer_key_id"] != originalKeyID {
        return "", fmt.Errorf("wrong schema or original key")
    }
    block, rest := pem.Decode(publicPEM)
    if block == nil || len(bytes.TrimSpace(rest)) != 0 {
        return "", fmt.Errorf("expected an RSA public key")
    }
    var parsed any
    var err error
    switch block.Type {
    case "PUBLIC KEY":
        parsed, err = x509.ParsePKIXPublicKey(block.Bytes)
    case "RSA PUBLIC KEY":
        parsed, err = x509.ParsePKCS1PublicKey(block.Bytes)
    default:
        return "", fmt.Errorf("expected an RSA public key")
    }
    if err != nil {
        return "", err
    }
    public, ok := parsed.(*rsa.PublicKey)
    if !ok || public.N.BitLen() != 3072 {
        return "", fmt.Errorf("expected RSA-3072")
    }
    wrapped, err := decode64(access["recovery_secret"])
    if err != nil || len(wrapped) != 384 {
        return "", fmt.Errorf("wrong RSA ciphertext length")
    }
    der, err := x509.MarshalPKIXPublicKey(public)
    if err != nil {
        return "", err
    }
    expectedFingerprint := sha256.Sum256(der)
    fingerprint, err := decode64(access["customer_public_key_fingerprint"])
    if err != nil || subtle.ConstantTimeCompare(fingerprint, expectedFingerprint[:]) != 1 {
        return "", fmt.Errorf("wrong key fingerprint")
    }
    encoded, err := decode64(record["safety_review_runtime_public_key"])
    if err != nil || len(encoded) != 65 || encoded[0] != 4 {
        return "", fmt.Errorf("invalid P-256 encoding")
    }
    runtime, err := ecdh.P256().NewPublicKey(encoded)
    if err != nil {
        return "", err
    }
    encode := base64.RawURLEncoding.EncodeToString
    jwk, err := canonical(map[string]any{"crv": "P-256", "kty": "EC", "x": encode(encoded[1:33]), "y": encode(encoded[33:])})
    if err != nil {
        return "", err
    }
    thumbprint := sha256.Sum256(jwk)
    if record["key_thumbprint"] != encode(thumbprint[:]) {
        return "", fmt.Errorf("wrong runtime key")
    }
    nonce, err := decode64(record["nonce"])
    if err != nil || len(nonce) != 12 {
        return "", fmt.Errorf("invalid AES-GCM nonce")
    }
    ciphertext, err := decode64(record["ciphertext"])
    if err != nil || len(ciphertext) < 16 {
        return "", fmt.Errorf("invalid AES-GCM ciphertext")
    }
    bindingJSON, err := canonical(map[string]any{"purpose": "OpenAI-PSP-v4/customer-recovery-binding", "bundle_version": 1, "record": record, "recovery_header": without(access, "recovery_secret")})
    if err != nil {
        return "", err
    }
    binding := sha256.Sum256(bindingJSON)
    if len(capsule) != 72 || string(capsule[:8]) != "PSPv4\x00\x00\x01" || subtle.ConstantTimeCompare(capsule[40:], binding[:]) != 1 {
        return "", fmt.Errorf("invalid recovery capsule binding")
    }
    ephemeral, err := ecdh.P256().NewPrivateKey(capsule[8:40])
    if err != nil {
        return "", err
    }
    enc, err := decode64(record["encrypted_dek"])
    if err != nil || subtle.ConstantTimeCompare(enc, ephemeral.PublicKey().Bytes()) != 1 {
        return "", fmt.Errorf("wrong recovered scalar")
    }
    aad, err := canonical(without(record, "ciphertext"))
    if err != nil {
        return "", err
    }
    key, err := payloadKey(ephemeral, runtime, aad)
    if err != nil {
        return "", err
    }
    cipherBlock, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }
    aead, err := cipher.NewGCM(cipherBlock)
    if err != nil {
        return "", err
    }
    plaintext, err := aead.Open(nil, nonce, ciphertext, aad)
    if err != nil {
        return "", errAuthentication
    }
    if !utf8.Valid(plaintext) {
        return "", fmt.Errorf("plaintext is not UTF-8")
    }
    return string(plaintext), nil
}

require "base64"
require "digest"
require "json"
require "json/canonicalization"
require "openssl"
require "hpke"

def require_valid(condition, message)
  raise ArgumentError, message unless condition
end

def b64url(bytes)
  Base64.urlsafe_encode64(bytes, padding: false)
end

def decode64(value)
  require_valid(value.is_a?(String), "Expected base64url text")
  bytes = Base64.strict_decode64(value.tr("-_", "+/") + "=" * (-value.length % 4))
  require_valid(b64url(bytes) == value, "Noncanonical base64url")
  bytes
end

def equal_bytes?(left, right)
  left.bytesize == right.bytesize && OpenSSL.fixed_length_secure_compare(left, right)
end

def recovery_point(kem, value)
  encoded = decode64(value)
  require_valid(encoded.bytesize == 65 && encoded.getbyte(0) == 4, "Invalid P-256 encoding")
  key = kem.deserialize_public_key(encoded)
  require_valid(key.check_key, "Invalid P-256 point")
  [key, encoded]
rescue OpenSSL::PKey::PKeyError
  raise ArgumentError, "Invalid P-256 point"
end

## 用内部记录包的原始字节和已解密的密封包恢复记录。
## 本地恢复无需调用云服务。RSA 私钥保留在云端。
def recover_record(bundle_json, capsule, original_key_id, original_public_key_pem)
  bundle = JSON.parse(bundle_json, allow_duplicate_key: false)
  require_valid(
    bundle["bundle_version"].is_a?(Integer) && bundle["bundle_version"] == 1,
    "Unsupported bundle version"
  )
  record = bundle.fetch("protected_record")
  access = bundle.fetch("customer_access")
  require_valid(access.is_a?(Hash), "Customer recovery is unavailable")
  require_valid(
    record["version"] == "v4" &&
        record["algorithm"] == "HPKE-v1-DHKEM_P256_HKDF_SHA256-EXPORT_ONLY-AES256_GCM" &&
        access["version"].is_a?(Integer) && access["version"] == 1 &&
        access["algorithm"] == "RSA-OAEP-256" && access["customer_key_id"] == original_key_id,
    "Wrong schema or original key"
  )

  public_key = OpenSSL::PKey.read(original_public_key_pem)
  require_valid(public_key.is_a?(OpenSSL::PKey::RSA) && !public_key.private?, "Expected an RSA public key")
  require_valid(public_key.n.num_bits == 3072, "Expected RSA-3072")
  require_valid(
    decode64(access.fetch("recovery_secret")).bytesize == 384,
    "Wrong RSA ciphertext length"
  )
  fingerprint = Digest::SHA256.digest(public_key.public_to_der)
  require_valid(equal_bytes?(decode64(access.fetch("customer_public_key_fingerprint")), fingerprint), "Wrong key")

  suite = HPKE.new(HPKE::DHKEM_P256_HKDF_SHA256, HPKE::HKDF_SHA256, HPKE::EXPORT_ONLY)
  runtime, encoded = recovery_point(suite.kem, record.fetch("safety_review_runtime_public_key"))
  jwk = {
    "crv" => "P-256",

    "kty" => "EC",

    "x" => b64url(encoded.byteslice(1, 32)),
    "y" => b64url(encoded.byteslice(33, 32))
  }
  require_valid(record["key_thumbprint"] == b64url(Digest::SHA256.digest(jwk.to_json_c14n)), "Wrong runtime key")
  nonce = decode64(record.fetch("nonce"))
  ciphertext = decode64(record.fetch("ciphertext"))
  require_valid(nonce.bytesize == 12 && ciphertext.bytesize >= 16, "Invalid AES-GCM encoding")

  binding_input = {
    "purpose" => "OpenAI-PSP-v4/customer-recovery-binding",

    "bundle_version" => 1,
    "record" => record,

    "recovery_header" => access.except("recovery_secret")
  }
  binding = Digest::SHA256.digest(binding_input.to_json_c14n)
  require_valid(
    capsule.is_a?(String) && capsule.bytesize == 72 &&
        capsule.byteslice(0, 8) == "PSPv4\x00\x00\x01".b && equal_bytes?(capsule.byteslice(40, 32), binding),
    "Invalid recovery capsule binding"
  )
  secret = capsule.byteslice(8, 32)
  scalar = OpenSSL::BN.new(secret, 2).to_i
  order = 0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
  require_valid(scalar >= 1 && scalar < order, "Invalid P-256 private scalar")

  # 在这个 KEM 实例上恢复密钥。
  # 库沿用原加密过程的参数执行 HPKE 封装与密钥调度,
  # 无需另生成会改变派生结果的临时密钥。
  ephemeral = suite.kem.create_key_pair_from_secret(secret)
  suite.kem.define_singleton_method(:generate_key_pair) { ephemeral }
  sender = suite.setup_base_s(runtime, "OpenAI-PSP-v4/HPKE-export")
  require_valid(sender.fetch(:enc) == decode64(record.fetch("encrypted_dek")), "Wrong recovered scalar")
  aad = record.except("ciphertext").to_json_c14n
  key = sender.fetch(:context_s).export("OpenAI-PSP-v4/payload-key" + Digest::SHA256.digest(aad), 32)

  cipher = OpenSSL::Cipher.new("aes-256-gcm")
  cipher.decrypt
  cipher.key = key
  cipher.iv = nonce
  cipher.auth_tag = ciphertext.byteslice(-16, 16)
  cipher.auth_data = aad
  encrypted_body = ciphertext.byteslice(0, ciphertext.bytesize - 16)
  plaintext = encrypted_body.empty? ? "".b : cipher.update(encrypted_body)
  plaintext << cipher.final
  plaintext.force_encoding(Encoding::UTF_8)
  require_valid(plaintext.valid_encoding?, "Recovered plaintext is not UTF-8")
  plaintext
end

恢复后的内容

对于解密后 JSON 中 format 为 "psp_request_v1" 的请求记录,request_text 是保留的请求文本。其他字段包括 reasoning_summaries(字符串数组)、request_text_truncated(布尔值)和 reasoning_summary_parts_omitted(非负整数)。解读内容前请检查截断标记。其他受保护内容类型的明文格式可能不同。

如果原客户恢复密钥及公钥快照仍可用,即使 OpenAI 运行时密钥已过期,客户也可继续恢复。保持经过认证的 expires_at 字段原值。encrypted_cot 仍独立加密。

以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号