4. 基于SHA-256的固件版本完整性校验

任务目标

在固件升级流程中，对下载到本地的新固件计算SHA-256哈希值，并与服务器下发的参考哈希进行比对。若两者一致则判定固件完整，允许进入升级流程；否则丢弃固件并报错，防止因传输损坏或恶意篡改导致升级失败。

环境与依赖

  • 硬件：STM32F407开发板（或其他带硬件CRC/加密加速器的Cortex-M4 MCU）
  • 软件：STM32CubeIDE 或 Keil MDK-ARM
  • 依赖库：STM32 HAL 驱动（本文使用HAL库实现）
  • 哈希算法：使用STM32硬件加密单元（CRYP）或软件实现SHA-256。本案例采用软件SHA-256实现（无硬件依赖，便于移植），代码约200行，直接嵌入工程即可。

核心实现

以下代码实现SHA-256计算与固件校验逻辑。固件数据通过firmware_data指针传入，长度由firmware_len指定。参考哈希以字节数组形式给出（示例中为全零占位，实际使用时替换为服务器下发的32字节哈希值）。

// sha256.h
#ifndef SHA256_H
#define SHA256_H
#include <stdint.h>
#include <stddef.h>

typedef struct {
    uint8_t data[64];
    uint32_t datalen;
    uint64_t bitlen;
    uint32_t state[8];
} SHA256_CTX;

void sha256_init(SHA256_CTX *ctx);
void sha256_update(SHA256_CTX *ctx, const uint8_t *data, size_t len);
void sha256_final(SHA256_CTX *ctx, uint8_t hash[32]);
#endif

// sha256.c
#include "sha256.h"
#include <string.h>

#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))

static const uint32_t k[64] = {
    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
};

void sha256_transform(SHA256_CTX *ctx, const uint8_t data[]) {
    uint32_t a,b,c,d,e,f,g,h,t1,t2,m[64];
    int i;
    for (i = 0; i < 16; i++)
        m[i] = (data[i*4] << 24) | (data[i*4+1] << 16) | (data[i*4+2] << 8) | data[i*4+3];
    for (i = 16; i < 64; i++)
        m[i] = SIG1(m[i-2]) + m[i-7] + SIG0(m[i-15]) + m[i-16];
    a = ctx->state[0]; b = ctx->state[1]; c = ctx->state[2]; d = ctx->state[3];
    e = ctx->state[4]; f = ctx->state[5]; g = ctx->state[6]; h = ctx->state[7];
    for (i = 0; i < 64; i++) {
        t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
        t2 = EP0(a) + MAJ(a,b,c);
        h = g; g = f; f = e; e = d + t1;
        d = c; c = b; b = a; a = t1 + t2;
    }
    ctx->state[0] += a; ctx->state[1] += b; ctx->state[2] += c; ctx->state[3] += d;
    ctx->state[4] += e; ctx->state[5] += f; ctx->state[6] += g; ctx->state[7] += h;
}

void sha256_init(SHA256_CTX *ctx) {
    ctx->datalen = 0; ctx->bitlen = 0;
    ctx->state[0] = 0x6a09e667; ctx->state[1] = 0xbb67ae85;
    ctx->state[2] = 0x3c6ef372; ctx->state[3] = 0xa54ff53a;
    ctx->state[4] = 0x510e527f; ctx->state[5] = 0x9b05688c;
    ctx->state[6] = 0x1f83d9ab; ctx->state[7] = 0x5be0cd19;
}

void sha256_update(SHA256_CTX *ctx, const uint8_t *data, size_t len) {
    size_t i;
    for (i = 0; i < len; i++) {
        ctx->data[ctx->datalen] = data[i];
        ctx->datalen++;
        if (ctx->datalen == 64) {
            sha256_transform(ctx, ctx->data);
            ctx->bitlen += 512;
            ctx->datalen = 0;
        }
    }
}

void sha256_final(SHA256_CTX *ctx, uint8_t hash[32]) {
    uint32_t i = ctx->datalen;
    ctx->data[i++] = 0x80;
    if (i > 56) {
        while (i < 64) ctx->data[i++] = 0;
        sha256_transform(ctx, ctx->data);
        i = 0;
    }
    while (i < 56) ctx->data[i++] = 0;
    ctx->bitlen += ctx->datalen * 8;
    ctx->data[63] = ctx->bitlen;
    ctx->data[62] = ctx->bitlen >> 8;
    ctx->data[61] = ctx->bitlen >> 16;
    ctx->data[60] = ctx->bitlen >> 24;
    ctx->data[59] = ctx->bitlen >> 32;
    ctx->data[58] = ctx->bitlen >> 40;
    ctx->data[57] = ctx->bitlen >> 48;
    ctx->data[56] = ctx->bitlen >> 56;
    sha256_transform(ctx, ctx->data);
    for (i = 0; i < 4; i++) {
        hash[i]   = (ctx->state[0] >> (24 - i*8)) & 0xff;
        hash[i+4] = (ctx->state[1] >> (24 - i*8)) & 0xff;
        hash[i+8] = (ctx->state[2] >> (24 - i*8)) & 0xff;
        hash[i+12]= (ctx->state[3] >> (24 - i*8)) & 0xff;
        hash[i+16]= (ctx->state[4] >> (24 - i*8)) & 0xff;
        hash[i+20]= (ctx->state[5] >> (24 - i*8)) & 0xff;
        hash[i+24]= (ctx->state[6] >> (24 - i*8)) & 0xff;
        hash[i+28]= (ctx->state[7] >> (24 - i*8)) & 0xff;
    }
}

// 固件校验函数
#include <stdbool.h>

bool verify_firmware_integrity(const uint8_t *firmware_data, uint32_t firmware_len,
                               const uint8_t *expected_hash) {
    uint8_t computed_hash[32];
    SHA256_CTX ctx;
    sha256_init(&ctx);
    sha256_update(&ctx, firmware_data, firmware_len);
    sha256_final(&ctx, computed_hash);
    return memcmp(computed_hash, expected_hash, 32) == 0;
}

调用示例

// 使用示例（在升级流程中调用）
uint8_t server_hash[32] = {0};  // 实际使用时填充服务器下发的32字节哈希
uint8_t *new_firmware = (uint8_t*)0x08020000;  // 固件暂存地址
uint32_t fw_size = 0x40000;      // 固件大小（256KB）

if (verify_firmware_integrity(new_firmware, fw_size, server_hash)) {
    // 哈希匹配，执行升级（擦写Flash等）
    start_firmware_update(new_firmware, fw_size);
} else {
    // 哈希不匹配，丢弃固件并报错
    handle_firmware_corrupted();
}

验证方法

  1. 准备测试固件：取任意已知内容的二进制文件（如100字节的测试数据），用PC端工具（如sha256sum）计算其SHA-256值，得到32字节参考哈希。
  2. 将测试固件烧录到MCU的暂存区域（如外部Flash或内存），将参考哈希填入server_hash数组。
  3. 调用verify_firmware_integrity()，观察返回值：
  • 通过条件：返回true，程序进入升级分支（可在此处设置LED翻转或串口打印“PASS”）。
  • 失败验证：故意修改固件中任意一个字节（如将最后一个字节+1），再次调用，应返回false，进入错误处理分支。

常见问题

  • 内存不足：SHA-256上下文占用约108字节栈空间，在中断中调用时注意栈大小。
  • 性能：软件SHA-256在168MHz的STM32F4上处理256KB固件约需1~2秒（视优化等级），若需加速可改用硬件CRYP单元。
  • 哈希比对安全：建议使用memcmp的常量时间实现（如逐字节异或累积），防止时序侧信道攻击。
← 上一章 📖 返回目录 下一章 →