3、固件签名工具链：OpenSSL命令行工具、Python cryptography库、HASH计算与验证

做固件签名，说白了就是给固件打上一个「数字指纹」加「数字印章」。你得先算哈希，再用私钥加密这个哈希。整个过程离不开一套趁手的工具链。我个人习惯用两套工具：OpenSSL 命令行和 Python cryptography 库。前者适合快速验证和脚本集成，后者适合嵌入到自动化流水线里。

嗯，咱们这一章就把这两套工具怎么用、哈希怎么算、签名怎么验，掰开揉碎讲清楚。

3.1 哈希计算：固件的「数字指纹」

签名之前，第一步永远是算哈希。为什么？因为非对称加密太慢了。你想想看，一个几兆字节的固件，如果用私钥直接加密整个文件，那得等到天荒地老。所以实际做法是：先算一个固定长度的哈希值（比如 32 字节的 SHA-256），然后只对这个哈希值签名。

哈希函数有几个关键特性：

• 单向性：从哈希值反推原始数据，理论上不可能。
• 抗碰撞性：找到两个不同文件有相同哈希值，极其困难。
• 雪崩效应：改一个比特，哈希值完全变样。

我在项目中遇到过有人用 MD5 做固件签名，结果被碰撞攻击轻松绕过。嗯，从那以后我定了个死规矩：生产环境只用 SHA-256 或更高。

3.1.1 用 OpenSSL 计算哈希

OpenSSL 命令行算哈希，一行搞定：

# 计算固件文件的 SHA-256 哈希值
openssl dgst -sha256 firmware.bin

# 输出示例：
# SHA256(firmware.bin)= a1b2c3d4e5f6... （64个十六进制字符）

如果你想把哈希值保存到文件里，方便后面签名用：

openssl dgst -sha256 -binary -out firmware.hash firmware.bin

-binary 参数输出原始二进制格式，32 字节。不加的话输出的是十六进制文本格式，长度 64 字节。我个人习惯用二进制格式，因为签名工具直接处理二进制更省事。

3.1.2 用 Python cryptography 计算哈希

Python 这边，我推荐用 cryptography 库，而不是内置的 hashlib。为什么？因为 cryptography 的接口更统一，而且后续做签名验签也用它，不用来回切换。

from cryptography.hazmat.primitives import hashes

def calculate_sha256(file_path):
    digest = hashes.Hash(hashes.SHA256())
    with open(file_path, 'rb') as f:
        while chunk := f.read(4096):
            digest.update(chunk)
    return digest.finalize()

# 使用示例
hash_value = calculate_sha256('firmware.bin')
print(hash_value.hex())  # 打印十六进制字符串

这里我用了分块读取，每次 4KB。你想想看，如果固件有 100MB，一次性读到内存里，嵌入式开发机可能还好，但要是放在 CI 服务器上，内存吃紧的时候就会出问题。分块处理是生产环境的标配。

3.2 OpenSSL 命令行签名与验证

OpenSSL 是嵌入式开发者的瑞士军刀。它支持多种非对称算法，咱们这里以 RSA-2048 + SHA-256 为例，这是目前工业界最主流的组合。

3.2.1 生成密钥对

签名需要一对密钥：私钥自己保管，公钥分发到设备端。

# 生成 RSA 私钥（2048位）
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private.pem

# 从私钥导出公钥
openssl pkey -in private.pem -pubout -out public.pem

私钥文件一定要保护好。我在项目里见过有人把私钥直接提交到 Git 仓库里——嗯，那场面，简直是灾难。建议用硬件安全模块（HSM）或者至少用密码加密私钥文件：

# 生成加密的私钥（需要输入密码）
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -aes256 -out private_enc.pem

3.2.2 签名固件

签名分两步：先算哈希，再对哈希签名。OpenSSL 提供了 dgst -sign 一步到位：

# 一步完成哈希计算和签名
openssl dgst -sha256 -sign private.pem -out firmware.sig firmware.bin

生成的 firmware.sig 是原始签名数据（RSA-2048 下是 256 字节）。

如果你想自己控制流程，也可以分两步：

# 第一步：算哈希
openssl dgst -sha256 -binary -out firmware.hash firmware.bin

# 第二步：对哈希签名
openssl pkeyutl -sign -inkey private.pem -in firmware.hash -out firmware.sig

分步的好处是你可以把哈希值打印出来，人工确认一下。我在调试阶段经常这么干。

3.2.3 验证签名

验证签名需要公钥、原始固件和签名文件：

# 验证签名
openssl dgst -sha256 -verify public.pem -signature firmware.sig firmware.bin

# 输出：
# Verified OK

如果输出 Verified OK，说明固件没有被篡改，而且确实是用对应的私钥签名的。如果输出 Verification Failure，那就要警惕了——要么固件被改了，要么签名不匹配。

3.3 Python cryptography 库签名与验证

命令行工具适合手动操作和脚本调用，但如果你要构建一个完整的固件签名流水线，用 Python 库更灵活。我个人在自动化构建系统里全部用 cryptography 库。

3.3.1 加载密钥

from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding

# 加载私钥
with open('private.pem', 'rb') as f:
    private_key = serialization.load_pem_private_key(
        f.read(),
        password=None  # 如果有密码，在这里传入 bytes 类型密码
    )

# 加载公钥
with open('public.pem', 'rb') as f:
    public_key = serialization.load_pem_public_key(f.read())

3.3.2 签名固件

def sign_firmware(private_key, firmware_path, sig_path):
    # 计算哈希
    digest = hashes.Hash(hashes.SHA256())
    with open(firmware_path, 'rb') as f:
        while chunk := f.read(4096):
            digest.update(chunk)
    hash_value = digest.finalize()
    
    # 使用私钥签名
    signature = private_key.sign(
        hash_value,
        padding.PKCS1v15(),  # 填充方案
        hashes.SHA256()
    )
    
    # 保存签名文件
    with open(sig_path, 'wb') as f:
        f.write(signature)
    
    return signature

这里要注意 padding.PKCS1v15()。RSA 签名需要填充方案，PKCS#1 v1.5 是最常用的。还有一种更安全的方案叫 PSS，但很多嵌入式 bootloader 只支持 PKCS#1 v1.5，所以咱们先用这个。

3.3.3 验证签名

def verify_signature(public_key, firmware_path, sig_path):
    # 计算固件哈希
    digest = hashes.Hash(hashes.SHA256())
    with open(firmware_path, 'rb') as f:
        while chunk := f.read(4096):
            digest.update(chunk)
    hash_value = digest.finalize()
    
    # 读取签名
    with open(sig_path, 'rb') as f:
        signature = f.read()
    
    # 验证
    try:
        public_key.verify(
            signature,
            hash_value,
            padding.PKCS1v15(),
            hashes.SHA256()
        )
        return True
    except Exception as e:
        print(f"验证失败: {e}")
        return False

验证失败时，cryptography 库会抛出异常。不要只捕获 InvalidSignature，因为还可能因为密钥类型不匹配、填充方案不对等原因报错。我一般直接捕获 Exception，然后记录日志。

3.4 工具链对比与选择建议

我个人建议：开发调试阶段用 OpenSSL 命令行，因为快，一行命令就能验证思路对不对。生产构建系统用 Python cryptography，因为可以嵌入到构建脚本里，做更精细的错误处理和日志记录。

3.5 核心流程总览

下面这张图把整个签名验证流程串起来了。你可以看到，签名方和验证方做的事情是对称的：

这张图把流程分成了左右两半。左边是你在开发机上做的事：算哈希、用私钥签名、生成 .sig 文件。右边是设备端 bootloader 做的事：同样算哈希、用公钥解密签名、比对两个哈希值是否一致。

你可能会问：为什么设备端不直接解密整个固件？嗯，原因还是性能。设备端的 CPU 通常比开发机弱得多，解密 256 字节的签名和加密几兆字节的固件，计算量差了几个数量级。

3.6 避坑指南

做固件签名这几年，我踩过不少坑。挑几个典型的说说：

• 哈希算法不匹配：签名时用 SHA-256，验证时用 SHA-1，结果死活验不过。我曾经在升级一个老项目时犯过这个错，排查了半天才发现是 bootloader 里写死了 SHA-1。
• 填充方案不一致：OpenSSL 默认用 PKCS#1 v1.5，但有些硬件加密模块只支持 PSS。签名前一定要确认目标平台的 bootloader 支持哪种填充方案。
• 字节序问题：有些 MCU 是大端模式，签名数据如果按小端生成，验签就会失败。我建议签名时统一用网络字节序（大端），或者至少在签名数据头部加一个字节序标记。
• 签名文件格式：不要把签名直接追加到固件末尾就完事了。最好定义一套清晰的固件包格式，包含头部、固件数据、签名、元数据等字段。下一章我会详细讲这个。