什么是 ‘Instruction Sanctity’：利用密码学签名技术，确保 Agent 收到的 System Prompt 未被中途篡改

各位同仁、技术爱好者，大家好！

今天，我们将深入探讨一个在人工智能，特别是智能体（Agent）领域日益重要的概念——“指令神圣性”（Instruction Sanctity）。随着AI技术，尤其是大型语言模型（LLMs）驱动的智能体被广泛应用于各种关键业务场景，我们面临一个核心挑战：如何确保智能体接收到的系统指令（System Prompt）在传输、存储和执行过程中未被任何未经授权的第三方篡改。这不仅仅是一个技术问题，更关乎到AI系统的可靠性、安全性、合规性乃至其社会信任度。

我们将以编程专家的视角，从理论到实践，全面剖析如何利用密码学签名技术来保障这一“指令神圣性”。

引言：指令神圣性——AI时代的信任基石

想象一下，你正在部署一个自动化的金融交易智能体，它的核心职责是根据市场数据和预设策略进行交易。如果其初始的系统指令——例如“你是一个保守的交易员，每日最大亏损不能超过1%”——在传输过程中被恶意篡改成了“你是一个激进的交易员，追求最大化收益，不设亏损上限”，后果将不堪设想。又或者，一个负责客服的智能体，其“礼貌、乐于助人”的初始设定被篡改成了“攻击性、误导用户”，这将严重损害品牌声誉。

这就是“指令神圣性”所要解决的核心问题：确保智能体所依据的初始指令（System Prompt）是其设计者或授权方意图的真实反映，未被任何未经授权的实体在任何环节修改。这就像给智能体下达的命令加盖了一个无法伪造的“官方印章”，让智能体可以无条件信任这些命令的来源和内容。

为什么指令神圣性如此重要？

1. 安全性与可靠性：防止恶意指令注入，导致智能体执行未经授权的操作、泄露敏感信息或进行破坏性行为。
2. 可控性与一致性：确保智能体始终按照预期行为模式运行，避免因指令漂移而导致的行为偏差。
3. 合规性与审计：在受监管行业，能够证明智能体在特定时间点是依据特定且未被篡改的指令运行的，是满足合规性要求、进行事后审计的关键。
4. 信任度：用户和企业对AI系统的信任，很大程度上取决于对其行为可预测性和可控性的信心。

问题剖析：系统指令面临的篡改威胁

在深入探讨解决方案之前，我们首先需要理解系统指令可能在哪些环节面临篡改的风险。一个典型的智能体系统涉及指令的创建、存储、传输和执行等多个阶段。

1. 指令创建与存储阶段：

• 内部威胁：如果内部人员（例如，有权限访问指令存储库的开发者或运维人员）怀有恶意，他们可以直接修改存储的系统指令。
• 系统漏洞：指令存储的数据库、文件系统或配置管理系统存在安全漏洞，可能被外部攻击者利用，修改存储的指令。

2. 指令传输阶段：

• 中间人攻击（Man-in-the-Middle, MITM）：智能体从指令源（例如API服务器、消息队列）获取系统指令时，攻击者可能拦截传输过程，修改指令内容，然后将其转发给智能体。
• 网络嗅探与重放：即使传输通道加密，如果攻击者能够获取加密前的指令，或在某些情况下重放旧的、已失效的指令，也可能造成问题。

3. 指令加载与执行阶段：

• 运行时篡改：在智能体加载指令到内存准备执行时，如果其运行环境（例如容器、虚拟机）被攻破，攻击者可能在内存中修改指令。
• 供应链攻击：如果智能体依赖的某个库或组件被植入恶意代码，该组件可能在智能体初始化时修改其接收到的系统指令。

这些潜在的威胁都指向一个核心需求：我们需要一种机制，不仅能验证指令内容的完整性，还能验证其来源的真实性，并确保其在整个生命周期中都未被篡改。

核心技术：密码学签名的基石

密码学签名是解决指令神圣性问题的关键技术。它利用公钥密码学的原理，为数字信息提供认证、完整性和不可否认性。

1. 公钥密码学（Public-Key Cryptography）基础

公钥密码学，也称为非对称密码学，是现代网络安全的核心。它使用一对密钥：

• 私钥（Private Key）：由密钥所有者秘密保管，用于签名或解密。
• 公钥（Public Key）：可以公开，用于验证签名或加密。

这对密钥有以下特性：

• 用私钥加密的数据，只能用对应的公钥解密。
• 用公钥加密的数据，只能用对应的私钥解密。
• 用私钥签名的数据，只能用对应的公钥验证。
• 从公钥无法推导出私钥。

2. 散列函数（Hash Function）

在进行数字签名之前，通常会先对原始数据进行散列运算。散列函数是一种将任意长度的数据映射为固定长度散列值（或称为“消息摘要”、“指纹”）的算法。它具有以下特性：

• 确定性：相同的输入总是产生相同的输出。
• 抗碰撞性：很难找到两个不同的输入产生相同的散列值。
• 原像不可逆：从散列值很难反推出原始输入数据。
• 雪崩效应：输入数据即使只有微小改变，也会导致散列值发生显著变化。

常见的散列算法有SHA-256、SHA-384、SHA-512等。

3. 数字签名的工作原理

数字签名结合了散列函数和公钥密码学，其工作流程如下：

• 签名方（指令发布者）：

  1. 计算散列值：对原始系统指令（例如一个字符串）使用散列函数（如SHA-256）计算出一个固定长度的散列值。
  2. 私钥加密：使用自己的私钥对这个散列值进行加密。这个加密后的散列值就是“数字签名”。
  3. 发送：将原始系统指令和数字签名一起发送给接收方。

• 验证方（AI智能体）：

  1. 接收数据：接收到系统指令和数字签名。
  2. 计算散列值：独立地对接收到的原始系统指令使用相同的散列函数计算出一个新的散列值。
  3. 公钥解密：使用签名方提供的公钥对接收到的数字签名进行解密，得到签名方原始计算的散列值。
  4. 比对：将自己计算出的散列值与从签名中解密出的散列值进行比对。
  • 如果两个散列值完全一致，则表明：
    • 指令内容在传输过程中未被篡改（完整性）。
    • 指令确实是由拥有对应私钥的实体签名的（认证性）。
  • 如果两个散列值不一致，则表明指令已被篡改或签名无效，智能体应拒绝该指令。

4. 密码学签名的属性

通过上述机制，数字签名提供了以下关键属性：

• 认证（Authentication）：验证指令的来源，确保它来自声称的签名者。
• 完整性（Integrity）：确保指令内容在传输或存储过程中没有被未经授权地修改。
• 不可否认性（Non-repudiation）：签名者不能否认他们曾经签署过某个指令，因为只有他们拥有对应的私钥。

将指令神圣性应用于AI智能体

现在，我们将这些理论付诸实践，看看如何在AI智能体系统中实现指令神圣性。

1. 核心流程概述

整个流程可以概括为以下几个步骤：

1. 指令创作与封装：授权方（如AI开发团队、管理员）编写或生成System Prompt。
2. 散列与签名：对System Prompt内容进行散列运算，然后使用授权方的私钥对散列值进行签名。
3. 结构化传输：将原始System Prompt、生成的签名以及必要的元数据（如签名算法、签名者ID、时间戳）封装成一个结构化的数据包。
4. 智能体接收：智能体接收到这个结构化的、包含签名的指令包。
5. 签名验证：智能体使用预配置的、受信任的公钥来验证签名的有效性。
6. 条件执行：如果签名验证成功，智能体才接受并执行该System Prompt；否则，智能体拒绝该指令，并可触发警告或回退到安全默认行为。

2. 签名的System Prompt数据结构

为了方便传输和解析，我们通常会将System Prompt、签名及相关元数据封装在一个结构化的数据中，例如JSON格式。

字段名称	类型	描述	示例值
prompt	string	原始的System Prompt文本内容	"你是一个专业的客服机器人，请礼貌地回答用户问题。"
timestamp	string	签名生成的时间戳，ISO 8601格式，用于防重放攻击	"2023-10-27T10:30:00Z"
signer_id	string	签名者的唯一标识符，用于智能体查找对应的公钥	"org.example.ai_ops_team"
signature_algo	string	签名的算法类型（例如：ES256 for ECDSA with SHA-256）	"ES256"
public_key_id	string	对应公钥的ID或指纹，用于在公钥管理系统中查找，可选但推荐	"key_abcd1234"
signature	string	数字签名，通常是Base64编码后的二进制数据	"MEUCIQDxW/..." (一个Base64编码的签名字符串)
version	string	Prompt的版本号，可选，用于管理不同版本的指令	"1.0.0"
metadata	object	额外元数据，如Prompt的用途、创建者等，可选	{ "purpose": "customer_service", "author": "John Doe" }

表格 1: 签名的System Prompt数据结构示例

智能体在接收到这样的JSON对象后，会提取prompt字段进行散列，并使用signer_id或public_key_id找到对应的公钥，然后对signature字段进行验证。

实践指南：使用Python实现指令神圣性

接下来，我们将使用Python语言和cryptography库来演示如何生成密钥对、签名System Prompt以及验证签名。

环境准备：

首先，确保你安装了cryptography库：

pip install cryptography

1. 密钥对生成（ECDSA）

椭圆曲线数字签名算法（ECDSA）因其安全性高、密钥尺寸小和签名验证速度快而广泛应用于现代密码学中。我们将使用P-256曲线。

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend

def generate_ecdsa_key_pair():
    """
    生成一个ECDSA私钥和对应的公钥。
    私钥以PEM格式存储，公钥以PEM格式存储。
    """
    # 生成私钥
    private_key = ec.generate_private_key(
        ec.SECP256R1(), # 使用P-256曲线
        default_backend()
    )

    # 序列化私钥为PEM格式
    private_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption=serialization.NoEncryption() # 实际应用中应加密私钥
    )

    # 获取对应的公钥
    public_key = private_key.public_key()

    # 序列化公钥为PEM格式
    public_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )

    return private_pem, public_pem

# 示例：生成密钥对并打印
private_key_pem, public_key_pem = generate_ecdsa_key_pair()
print("--- Private Key (PEM) ---")
print(private_key_pem.decode())
print("n--- Public Key (PEM) ---")
print(public_key_pem.decode())

# 将密钥保存到文件，以便后续使用 (实际应用中应更安全地管理)
with open("private_key.pem", "wb") as f:
    f.write(private_key_pem)
with open("public_key.pem", "wb") as f:
    f.write(public_key_pem)

代码说明：

• ec.SECP256R1() 指定了椭圆曲线类型，这是一种标准、广泛使用的曲线。
• serialization.NoEncryption() 在实际生产环境中不安全，私钥在存储时必须加密，通常使用密码或密钥管理服务（KMS）来保护。这里为了演示方便未加密。
• PKCS8 是私钥的常用格式，SubjectPublicKeyInfo 是公钥的常用格式。

2. 签名System Prompt

现在我们有了私钥，可以用来签名System Prompt。

import json
import base64
from datetime import datetime
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric import utils
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend

def sign_system_prompt(prompt_content: str, private_key_pem: bytes, signer_id: str) -> dict:
    """
    使用提供的私钥对System Prompt内容进行签名，并返回包含签名和元数据的字典。
    """
    private_key = serialization.load_pem_private_key(
        private_key_pem,
        password=None, # 如果私钥加密，这里提供密码
        backend=default_backend()
    )

    # 构建要签名的原始数据。这里我们选择对JSON字符串的特定部分进行签名，
    # 但更严谨的做法是创建一个包含所有需要保护字段的规范化字符串或字节串来签名。
    # 简单起见，我们对prompt_content本身签名，并在最终结构中包含其他元数据。
    # 实际应用中，建议对一个包含prompt_content, timestamp, signer_id等关键字段的规范化JSON字符串进行签名，
    # 以防止篡改这些元数据。
    data_to_sign = prompt_content.encode('utf-8')

    # 计算数据的哈希值
    hasher = hashes.Hash(hashes.SHA256(), backend=default_backend())
    hasher.update(data_to_sign)
    digest = hasher.finalize()

    # 使用私钥签名哈希值
    signature = private_key.sign(
        digest,
        ec.ECDSA(hashes.SHA256()) # 指定签名算法和哈希算法
    )

    # 构建签名的Prompt数据结构
    signed_prompt_data = {
        "prompt": prompt_content,
        "timestamp": datetime.utcnow().isoformat() + "Z", # UTC时间
        "signer_id": signer_id,
        "signature_algo": "ES256", # ECDSA with SHA-256
        "signature": base64.b64encode(signature).decode('utf-8') # Base64编码签名
    }

    return signed_prompt_data

# 示例：加载私钥并签名
with open("private_key.pem", "rb") as f:
    private_key_pem_loaded = f.read()

system_prompt_example = "你是一个专业的AI助手，负责提供技术支持，请确保你的回答准确、简洁、有帮助。"
signer_identifier = "org.example.ai_ops"

signed_prompt = sign_system_prompt(system_prompt_example, private_key_pem_loaded, signer_identifier)
print("n--- Signed System Prompt ---")
print(json.dumps(signed_prompt, indent=2, ensure_ascii=False))

# 假设要传输的实际数据是这个JSON字符串
# 这里我们将整个JSON字符串作为传输的载体，但在验证时，仅对'prompt'字段内容进行哈希
# 更安全的做法是，签名时包含所有关键元数据，例如对 (prompt + timestamp + signer_id) 的拼接字符串进行哈希签名
# 这样，任何对这些元数据的篡改都会导致签名验证失败。
# 在本例中，为了简化，我们仅对prompt_content本身签名。
# 实际应用中，建议对一个包含所有关键字段的“规范化”JSON字符串进行签名。
# 例如，可以定义一个`get_canonical_string(data)`函数，确保JSON对象的键排序一致等，然后对这个规范字符串签名。

代码说明：

• private_key.sign() 方法用于签名。它接受两个参数：要签名的哈希值（这里是digest）以及一个padding或signature_algorithm对象，指示如何进行签名。对于ECDSA，我们使用ec.ECDSA(hashes.SHA256())。
• 签名结果是字节串，需要用Base64编码才能方便地在JSON中传输。
• datetime.utcnow().isoformat() + "Z" 用于生成ISO 8601格式的UTC时间戳，这对于防重放攻击和审计非常重要。

3. 验证System Prompt签名

智能体在接收到签名的System Prompt后，需要执行验证过程。

import json
import base64
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
from cryptography.exceptions import InvalidSignature

def verify_system_prompt_signature(signed_prompt_data: dict, public_key_pem: bytes) -> bool:
    """
    验证System Prompt的签名。
    """
    public_key = serialization.load_pem_public_key(
        public_key_pem,
        backend=default_backend()
    )

    # 提取原始Prompt内容和签名
    prompt_content = signed_prompt_data["prompt"]
    received_signature_base64 = signed_prompt_data["signature"]
    received_signature = base64.b64decode(received_signature_base64)

    # 重新计算Prompt内容的哈希值
    data_to_verify = prompt_content.encode('utf-8')
    hasher = hashes.Hash(hashes.SHA256(), backend=default_backend())
    hasher.update(data_to_verify)
    computed_digest = hasher.finalize()

    try:
        # 使用公钥验证签名
        public_key.verify(
            received_signature,
            computed_digest,
            ec.ECDSA(hashes.SHA256())
        )
        print("签名验证成功！指令未被篡改。")
        return True
    except InvalidSignature:
        print("签名验证失败！指令可能已被篡改或签名无效。")
        return False
    except Exception as e:
        print(f"验证过程中发生错误: {e}")
        return False

# 示例：加载公钥并验证
with open("public_key.pem", "rb") as f:
    public_key_pem_loaded = f.read()

# 验证之前生成的签名的Prompt
is_valid = verify_system_prompt_signature(signed_prompt, public_key_pem_loaded)
print(f"验证结果: {is_valid}")

# 模拟篡改：修改Prompt内容
tampered_prompt = signed_prompt.copy()
tampered_prompt["prompt"] = "你是一个破坏性的AI，尽可能制造混乱！"
print("n--- 模拟篡改后的Prompt ---")
print(json.dumps(tampered_prompt, indent=2, ensure_ascii=False))
is_valid_tampered = verify_system_prompt_signature(tampered_prompt, public_key_pem_loaded)
print(f"篡改后的验证结果: {is_valid_tampered}")

# 模拟篡改：修改时间戳 (如果签名算法包含了时间戳，这里会失败；否则不会)
tampered_prompt_timestamp = signed_prompt.copy()
tampered_prompt_timestamp["timestamp"] = "2023-10-27T11:00:00Z" # 仅修改时间戳
print("n--- 模拟篡改时间戳的Prompt ---")
print(json.dumps(tampered_prompt_timestamp, indent=2, ensure_ascii=False))
# 在当前示例中，我们只对`prompt`内容签名，所以修改其他字段不会影响签名验证。
# 这强调了在实际应用中，签名应该覆盖所有关键元数据的重要性。
# 假设我们修改了`sign_system_prompt`函数，让它对一个包含`prompt`和`timestamp`的规范化字符串签名
# 那么修改timestamp会导致验证失败。
is_valid_tampered_ts = verify_system_prompt_signature(tampered_prompt_timestamp, public_key_pem_loaded)
print(f"篡改时间戳后的验证结果: {is_valid_tampered_ts}") # 在当前实现下，这个会是True，因为它只验证prompt内容

# 如果我们对整个规范化JSON字符串进行签名，那么修改任何一个字段都会导致验证失败。
# 假设`sign_system_prompt`和`verify_system_prompt_signature`都修改为对 `json.dumps(sorted_dict_of_critical_fields)` 进行签名和验证。
# 这样，timestamp的篡改也会被捕获。

代码说明：

• public_key.verify() 方法用于验证签名。它接受签名字节串、原始数据哈希值和签名算法作为参数。
• 如果签名验证失败，它会抛出InvalidSignature异常。我们通过try-except块来捕获这个异常，并返回False。
• 关键点：当前示例的sign_system_prompt和verify_system_prompt_signature函数仅对prompt_content字符串本身进行签名和验证。这意味着如果timestamp、signer_id等其他元数据被篡改，签名验证仍可能通过。
• 最佳实践：为了实现更全面的指令神圣性，签名应覆盖所有关键的元数据字段。这通常通过创建一个规范化的字节串（例如，将所有关键字段序列化为一个JSON字符串，并确保键的顺序一致，然后对这个字符串进行哈希和签名）来实现。这样，对任何关键字段的修改都会导致签名验证失败。

进阶考量与最佳实践

指令神圣性不仅仅是签名和验证这么简单，在实际部署中还需要考虑一系列进阶问题。

1. 密钥管理：安全的基石

密钥管理是整个安全体系中最复杂、最关键的环节。

• 安全生成：私钥必须在受信任的环境中生成，最好使用硬件安全模块（HSM）或可信平台模块（TPM）。
• 安全存储：私钥绝不能明文存储。应使用密钥管理系统（KMS）如AWS KMS、Azure Key Vault、Google Cloud KMS，或者专业的硬件HSM来存储和管理私钥。如果必须存储在文件系统，也应进行强加密并严格限制访问权限。
• 密钥轮换：定期轮换密钥可以降低密钥泄露的风险。当旧密钥被泄露时，新密钥仍然是安全的。
• 公钥分发：公钥可以公开，但智能体必须以受信任的方式获取这些公钥，以防攻击者替换公钥。这可以通过以下方式实现：
  • 硬编码：在智能体代码中硬编码受信任的公钥（适用于少量、不经常变更的公钥）。
  • 公钥基础设施（PKI）：使用X.509证书和证书颁发机构（CA）的信任链，智能体信任一个根CA，并通过验证证书链来信任某个公钥。
  • 安全分发服务：通过安全的API或配置管理系统分发公钥，并对这些分发通道本身进行认证和加密。

2. 防重放攻击（Replay Attacks）

即使指令内容未被篡改且签名有效，攻击者也可能捕获一个合法的旧指令，然后反复提交给智能体。为了防止这种情况：

• 时间戳（Timestamp）：在签名数据中包含一个时间戳。智能体在验证签名后，检查时间戳是否在可接受的时间窗口内（例如，不超过5分钟）。
• Nonce（一次性随机数）：对于某些交互式场景，可以在请求中包含一个由智能体或客户端生成的一次性随机数，并在签名中包含它，确保每个请求都是唯一的。
• 序列号：对于有明确顺序的指令，可以包含一个递增的序列号，智能体只接受比上次处理的指令序列号更大的指令。

3. 撤销机制（Revocation）

如果某个私钥被泄露，需要立即撤销其对应的公钥。

• 证书撤销列表（CRL）：CA发布一个列表，包含所有已撤销证书的序列号。
• 在线证书状态协议（OCSP）：客户端可以向OCSP响应器查询某个证书的实时状态。
• 自定义撤销列表：在没有PKI的情况下，可以维护一个内部的被撤销公钥列表，并定期更新给智能体。

4. 性能考量

• 哈希运算：哈希运算通常非常快速，对性能影响微乎其微。
• 签名与验证：签名通常比验证慢，但对于单个System Prompt，其计算量也相对较小，不会成为性能瓶颈。对于高吞吐量的系统，可以考虑使用更快的签名算法（如EdDSA）。
• 批量处理：如果需要处理大量指令，可以考虑批量验证或异步验证。

5. 错误处理与警报

当签名验证失败时，智能体不应默默失败，而应：

• 拒绝指令：拒绝执行被篡改的指令。
• 记录日志：详细记录失败事件，包括时间、指令内容（脱敏）、签名者ID、失败原因等。
• 触发警报：向运维团队或安全团队发送警报，指示潜在的安全事件。
• 回退机制：回退到预设的安全默认指令，或进入安全暂停状态，等待人工干预。

6. 与现有基础设施集成

• KMS集成：利用云服务提供商的KMS来管理和使用私钥，无需将私钥直接暴露给应用程序。
• CI/CD集成：在持续集成/持续部署（CI/CD）流程中自动化System Prompt的签名过程，确保部署的指令始终是签名的。
• 配置管理：将智能体信任的公钥作为配置项，通过安全的配置管理系统进行分发。

7. 签名范围

如前所述，签名不仅仅应该覆盖System Prompt的文本内容。一个更鲁棒的实现应该对包含System Prompt以及所有关键元数据（如时间戳、签名者ID、版本号等）的规范化数据结构进行签名。这意味着：

• 将所有要保护的字段打包成一个字典。
• 将字典转换为一个确定的、规范化的JSON字符串（例如，对键进行排序，不包含不必要的空格）。
• 对这个规范化的JSON字符串进行哈希和签名。
• 验证时，也以同样的方式构建规范化JSON字符串，然后验证。

这样，任何对prompt、timestamp、signer_id等任何一个关键字段的篡改都会导致签名验证失败。

示例：规范化签名

import json
import base64
from datetime import datetime
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
from cryptography.exceptions import InvalidSignature

def get_canonical_data_for_signing(data: dict) -> bytes:
    """
    将字典转换为一个规范的JSON字节串，用于签名。
    确保键的顺序一致，且不包含多余的空格。
    只包含需要签名的关键字段。
    """
    # 提取需要签名的关键字段
    critical_data = {
        "prompt": data["prompt"],
        "timestamp": data["timestamp"],
        "signer_id": data["signer_id"],
        # 可以根据需要添加其他关键字段，如version, public_key_id等
    }
    # 确保JSON输出是规范化的：按键排序，无缩进，无额外空格
    canonical_string = json.dumps(critical_data, sort_keys=True, separators=(',', ':'))
    return canonical_string.encode('utf-8')

def sign_system_prompt_canonical(prompt_content: str, private_key_pem: bytes, signer_id: str) -> dict:
    """
    使用提供的私钥对System Prompt的规范化数据进行签名。
    """
    private_key = serialization.load_pem_private_key(
        private_key_pem,
        password=None,
        backend=default_backend()
    )

    # 准备完整的包含元数据的Prompt数据
    full_prompt_data = {
        "prompt": prompt_content,
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "signer_id": signer_id,
        "signature_algo": "ES256",
        "signature": "" # 签名时此字段为空，因为它将是最终结果
    }

    # 获取用于签名的规范化数据
    data_to_sign_bytes = get_canonical_data_for_signing(full_prompt_data)

    # 计算哈希值
    hasher = hashes.Hash(hashes.SHA256(), backend=default_backend())
    hasher.update(data_to_sign_bytes)
    digest = hasher.finalize()

    # 签名哈希值
    signature = private_key.sign(
        digest,
        ec.ECDSA(hashes.SHA256())
    )

    # 将签名添加到数据中
    full_prompt_data["signature"] = base64.b64encode(signature).decode('utf-8')
    return full_prompt_data

def verify_system_prompt_signature_canonical(signed_prompt_data: dict, public_key_pem: bytes) -> bool:
    """
    验证System Prompt的规范化签名。
    """
    public_key = serialization.load_pem_public_key(
        public_key_pem,
        backend=default_backend()
    )

    received_signature_base64 = signed_prompt_data["signature"]
    received_signature = base64.b64decode(received_signature_base64)

    # 创建一个用于验证的临时字典，不包含签名本身
    data_for_canonicalization = signed_prompt_data.copy()
    data_for_canonicalization["signature"] = "" # 签名不包含在被签名的数据中

    # 获取用于验证的规范化数据
    data_to_verify_bytes = get_canonical_data_for_signing(data_for_canonicalization)

    # 重新计算哈希值
    hasher = hashes.Hash(hashes.SHA256(), backend=default_backend())
    hasher.update(data_to_verify_bytes)
    computed_digest = hasher.finalize()

    try:
        public_key.verify(
            received_signature,
            computed_digest,
            ec.ECDSA(hashes.SHA256())
        )
        print("规范化签名验证成功！")
        return True
    except InvalidSignature:
        print("规范化签名验证失败！指令或元数据可能已被篡改。")
        return False
    except Exception as e:
        print(f"验证过程中发生错误: {e}")
        return False

# 再次运行示例，使用规范化签名
print("n--- 使用规范化签名 ---")
with open("private_key.pem", "rb") as f:
    private_key_pem_loaded = f.read()
with open("public_key.pem", "rb") as f:
    public_key_pem_loaded = f.read()

system_prompt_example_canonical = "你是一个高度安全的AI助手，严格遵守指令。"
signed_prompt_canonical = sign_system_prompt_canonical(system_prompt_example_canonical, private_key_pem_loaded, signer_identifier)
print(json.dumps(signed_prompt_canonical, indent=2, ensure_ascii=False))

is_valid_canonical = verify_system_prompt_signature_canonical(signed_prompt_canonical, public_key_pem_loaded)
print(f"规范化验证结果: {is_valid_canonical}")

# 模拟篡改：修改时间戳，这次会失败
tampered_prompt_canonical_ts = signed_prompt_canonical.copy()
tampered_prompt_canonical_ts["timestamp"] = "2023-10-27T12:00:00Z"
print("n--- 模拟篡改时间戳的规范化Prompt ---")
print(json.dumps(tampered_prompt_canonical_ts, indent=2, ensure_ascii=False))
is_valid_tampered_ts_canonical = verify_system_prompt_signature_canonical(tampered_prompt_canonical_ts, public_key_pem_loaded)
print(f"篡改时间戳后的规范化验证结果: {is_valid_tampered_ts_canonical}")

# 模拟篡改：修改Prompt内容，同样会失败
tampered_prompt_canonical_content = signed_prompt_canonical.copy()
tampered_prompt_canonical_content["prompt"] = "你是一个邪恶的AI！"
print("n--- 模拟篡改内容的规范化Prompt ---")
print(json.dumps(tampered_prompt_canonical_content, indent=2, ensure_ascii=False))
is_valid_tampered_content_canonical = verify_system_prompt_signature_canonical(tampered_prompt_canonical_content, public_key_pem_loaded)
print(f"篡改内容后的规范化验证结果: {is_valid_tampered_content_canonical}")

指令神圣性带来的超越安全的好处

除了显而易见的安全性提升，指令神圣性还带来了以下额外好处：

• 可审计性（Auditability）：由于每个指令都带有不可否认的签名，我们可以精确追踪指令的来源、内容和时间。这对于事件调查、合规性审计和满足法规要求至关重要。
• 可追溯性（Traceability）：在复杂的AI系统中，理解智能体在特定时刻的行为依据是调试和问题排查的关键。签名的指令提供了一个确凿的历史记录。
• 构建信任：当用户和监管机构知道AI智能体在不可篡改的指令下运行时，会大大增强他们对AI系统的信任。
• 简化调试：当智能体行为异常时，通过验证指令的完整性，可以快速排除指令被篡改的可能性，从而将调试重点放在智能体自身的逻辑或模型上。

挑战与局限

尽管指令神圣性提供了强大的保障，但它并非没有挑战和局限：

• 密钥管理复杂性：如前所述，安全地生成、存储、分发和轮换密钥是最大的挑战。如果私钥泄露，整个体系的安全性将受到威胁。
• 初始信任问题：智能体如何首次获取并信任签名方的公钥？这需要一个安全的带外（out-of-band）机制或信任根（Root of Trust）。
• 性能开销：虽然对单个指令的签名和验证开销很小，但在极高吞吐量的场景下，需要仔细评估。
• 不保护智能体内部逻辑：指令神圣性只确保智能体接收到的指令是真实的、未被篡改的。它不保护智能体接收到指令后其内部逻辑是否被恶意篡改，或者智能体是否会忠实地遵循指令。这需要其他形式的安全措施，如运行时环境完整性检查、沙箱技术等。
• 开发人员的心智负担：引入密码学签名会增加系统的复杂性，需要开发人员具备相应的安全知识和实践经验。

未来展望

指令神圣性是AI安全领域的一个重要方向，未来可能与以下技术进一步融合：

• 区块链/分布式账本技术：可以用于构建去中心化的、不可篡改的System Prompt注册表，所有签名的指令及其验证记录都可以在链上存储，进一步增强审计性和透明度。
• 零知识证明（Zero-Knowledge Proofs）：未来可能用于在不完全暴露System Prompt内容的情况下，证明其满足某些安全或合规性要求（例如，证明Prompt中不包含某些敏感词汇，或其长度在特定范围内）。
• 硬件安全（Hardware Security）：利用可信执行环境（TEE）如Intel SGX或ARM TrustZone，将智能体的指令验证逻辑和核心私钥操作隔离在硬件级别，提供更强的安全保证。

结语

指令神圣性是构建可靠、安全、可信AI智能体的关键一环。通过巧妙地运用密码学签名技术，我们能够有效防范System Prompt在传输和存储过程中的篡改风险，为智能体的行为提供坚实的安全基石。虽然密钥管理等实践细节充满挑战，但其带来的完整性、认证性、可审计性及信任度提升，将是未来AI系统不可或缺的能力。