硬件加密中实现SHA (SHA-1 / SHA-256)

本篇总结

使用硬件 SHA 引擎，对数据生成 SHA-1 / SHA-224 / SHA-256 摘要。

硬件平台：本例程基于 W55MH32L-EVB 开发板运行。

采购推荐：点击前往 WIZnet 官方淘宝店铺 选购 W55MH32L-EVB

三阶段的优势

三阶段结构支持大文件、流数据或网络数据包的分段处理，无需一次性载入全部数据，降低内存占用。此外还支持 Clone 操作——在任意时刻拷贝当前上下文，得到中间状态的摘要快照，不打断主流程。

#include "w55mh32.h"
#include "wiz_sha.h"
#include <stdio.h>
#include <string.h>

WIZSHA1_Context ctx;     /* SHA-1 上下文 */
WIZSHA2_Context ctx2;    /* SHA-2 系列（224/256）上下文 */

/* Start：启动 SHA 引擎 */
WIZSHA1_Starts(&ctx);       // SHA-1
WIZSHA256_Starts(&ctx2);    // SHA-256

/* Update：分段输入数据（可多次调用） */
WIZSHA1_Update(&ctx, TestSHA, 100);   // SHA-1，输入 100 字节
WIZSHA256_Update(&ctx2, buf0, 0x40);  // SHA-256，输入 64 字节
WIZSHA256_Update(&ctx2, buf1, 0x40);  // SHA-256，继续输入 64 字节

/* Clone：拷贝当前上下文，得到中间摘要（不打断主流程） */
WIZSHA256_Clone(&ctx2, digest);       // 复制 ctx2 到 digest 缓冲区
ouputRes("SHA256 Clone result: ", digest, 32);

/* Finish：完成运算，输出最终哈希摘要 */
WIZSHA1_Finish(&ctx, digest);         // SHA-1 → digest
WIZSHA256_Finish(&ctx2, digest);      // SHA-256 → digest

如果你想自定义

• 选择算法 → 用 WIZSHA1_* 系列（20 字节摘要）或 WIZSHA256_* 系列（32 字节摘要）
• 分段处理大数据 → 多次调用 Update，每次传入部分数据块，无需一次性载入全部
• 获取中间摘要 → 用 Clone 拷贝上下文，主流程可继续 Update/Finish
• 摘要缓冲区大小 → SHA-1 需至少 20 字节，SHA-224 需 28 字节，SHA-256 需 32 字节

void SHA_Update_Test()
{
    uint16_t i;
    WIZSHA1_Context ctx;
    WIZSHA2_Context ctx2;
    uint8_t buf0[0x40];
    uint8_t buf1[0x40];
    uint8_t t0[] = "12";
    unsigned char TestSHA[100] =
        "012345678901234567890123456789012345678901234567890123456789012345678901"
        "2345678901234567890123456789";
    uint8_t digest[32] = {0};

    printf("Test SHA function...\r\n");

    /* ---- SHA-1 ---- */
    WIZSHA1_Starts(&ctx);
    WIZSHA1_Update(&ctx, TestSHA, 100);
    WIZSHA1_Finish(&ctx, digest);
    ouputRes("SHA160 result: ", digest, 16);

    /* ---- SHA-256（分两段输入 + Clone 中间摘要） ---- */
    memset(digest, 0, 32);
    memset(buf0, 'a', 0x40);
    memset(buf1, 'b', 0x40);

    WIZSHA256_Starts(&ctx2);
    WIZSHA256_Update(&ctx2, buf0, 0x40);
    WIZSHA256_Update(&ctx2, buf1, 0x40);
    WIZSHA256_Finish(&ctx2, digest);
    ouputRes("SHA256 result: ", digest, 32);

    /* ---- 重新计算，中途 Clone 拿中间摘要 ---- */
    memset(digest, 0, 32);
    memset(buf0, 'a', 0x40);
    memset(buf1, 'b', 0x40);
    WIZSHA256_Starts(&ctx2);
    WIZSHA256_Update(&ctx2, buf0, 0x40);
    WIZSHA256_Update(&ctx2, buf1, 0x40);

    WIZSHA256_Clone(&ctx2, digest);
    ouputRes("SHA256 Clone result: ", digest, 32);
    memset(digest, 0, 32);

    /* 主流程继续 Update 并 Finish，得到新摘要 */
    WIZSHA256_Update(&ctx2, buf0, 0x40);
    WIZSHA256_Update(&ctx2, buf1, 0x40);
    WIZSHA256_Finish(&ctx2, digest);
    ouputRes("SHA256 result: ", digest, 32);
}

void SHA_Func_Test()
{
    uint8_t TestSHA[100] =
        "01234567890123456789012345678901234567890123456789012"
        "34567890123456789012345678901234567890123456789";
    uint8_t Cipher_SHA256[] = {0x9c, 0xfe, 0x7f, 0xaf, 0xf7, 0x05, 0x42, 0x98,
                               0xca, 0x87, 0x55, 0x7e, 0x15, 0xa1, 0x02, 0x62,
                               0xde, 0x8d, 0x3e, 0xee, 0x77, 0x82, 0x74, 0x17,
                               0xfb, 0xdf, 0xea, 0x1c, 0x41, 0xb9, 0xec, 0x23};
    uint8_t Cipher_SHA1[] = {0x29, 0xb0, 0xe7, 0x87, 0x82, 0x71, 0x64,
                             0x5f, 0xff, 0xb7, 0xee, 0xc7, 0xdb, 0x4a,
                             0x74, 0x73, 0xa1, 0xc0, 0x0b, 0xc1};
    uint8_t Cipher_SHA224[] = {0x2C, 0x09, 0xD5, 0x93, 0x30, 0x73, 0x6C,
                               0x5D, 0x53, 0x19, 0x0B, 0x36, 0x7D, 0x2D,
                               0x91, 0xCE, 0x54, 0xA5, 0x4A, 0xD9, 0x59,
                               0xA1, 0x6D, 0x40, 0x01, 0x83, 0xF0, 0x7F};
    uint8_t au8Cipher[32] = {0};

    // SHA-1 测试
    memset(au8Cipher, 0, 32);
    WIZSHA_Sha(WIZSHA1, TestSHA, sizeof(TestSHA), au8Cipher, 20);
    r_printf((0 == memcmp(Cipher_SHA1, au8Cipher, 20)), "WIZSHA_Sha 160 test\n");

    // SHA-224 测试
    memset(au8Cipher, 0, 32);
    WIZSHA_Sha(WIZSHA224, TestSHA, sizeof(TestSHA), au8Cipher, 28);
    r_printf((0 == memcmp(Cipher_SHA224, au8Cipher, 28)),
             "WIZSHA_Sha 224 test\n");

    // SHA-256 测试
    memset(au8Cipher, 0, 32);
    WIZSHA_Sha(WIZSHA256, TestSHA, sizeof(TestSHA), au8Cipher, 32);
    r_printf((0 == memcmp(Cipher_SHA256, au8Cipher, 32)),
             "WIZSHA_Sha 256 test\n");
}

void SHA_Test() {
  SHA_Update_Test();   /* 三阶段流程测试 + Clone */
  SHA_Func_Test();     /* 一次性流程测试（SHA-1/224/256） */
}

void main(int args) {
  uint32_t ver = 1;
  RCC_ClocksTypeDef clocks;

  RCC_DeInit();
  RCC_HSEConfig(RCC_HSE_ON);
  RCC_WaitForHSEStartUp();

  RCC_PLLCmd(DISABLE);
  RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);  // 8MHz × 9 = 72MHz
  RCC_PLLCmd(ENABLE);
  while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
  RCC_HCLKConfig(RCC_SYSCLK_Div1);
  RCC_PCLK1Config(RCC_HCLK_Div2);
  RCC_PCLK2Config(RCC_HCLK_Div1);

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
  SysTick->CTRL |= 0x04;

  /* 使能加密引擎时钟/配置寄存器 */
  *(uint32_t *)(0x400210F0) = 0x01;
  *(uint32_t *)(0x40016C00) = 0xCDED3526;
  *(uint32_t *)(0x40016CCC) = 0x07;

  UART_Configuration(115200);
  WIZRAND_Init((uint32_t *)&u8RngBuff, sizeof(u8RngBuff));

  ver = wiz_crypt_version();
  DBG_PRINT("WIZnet CARD Secure Test Demo V1.0, secure lib version is "
            "V%02x.%02x.%02x.%02x\n",
            ver >> 24, (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF);
  DBG_PRINT("WIZnet CARD Crypt Test V1.0 start......\r\n");

  /* 仅运行 SHA 测试，其余算法测试保留但被屏蔽 */
  SHA_Test();

  // AES_Test();
  // DES_Test();
  // TDES_Test();
  // SM1_Test();
  // SM3_Test();
  // SM4_Test();
  // SM7_Test();

  DBG_PRINT("SHA test finished, program halted.\r\n");

  while (1) {}
}