在no_std无alloc环境下，基于类型状态模式实现通用SHA2哈希的技术问询

核心思路是利用Trait关联常量+关联类型，把不同SHA类型的上下文长度、哈希长度等差异封装到ShaType trait中，只需传递单一泛型参数就能自动推导所有所需常量，完全适配no_std无alloc环境，且所有特性都是稳定版Rust支持的。

步骤1：定义带关联常量的ShaType Trait #

把每种SHA类型需要的固定参数都声明为trait的关联常量和关联类型，这样所有泛型结构体都能通过trait bound获取这些值：

#![no_std]

// 定义SHA类型的核心特征，封装所有类型相关的常量和类型
trait ShaType {
    // 哈希输出的字节长度
    const HASH_LEN: usize;
    // 上下文状态数组的元素数量（比如SHA256是8个u32，SHA384是8个u64）
    const STATE_LEN: usize;
    // 输入块的字节大小
    const BLOCK_SIZE: usize;
    // 状态变量的基础类型（u32或u64）
    type StateUnit: Copy + Default;

    // 关联函数：返回该SHA类型的初始状态值
    fn initial_state() -> [Self::StateUnit; Self::STATE_LEN];
}

步骤2：为每种SHA类型实现ShaType Trait #

针对SHA256、SHA384等类型分别实现trait，填入对应常量和初始状态：

// SHA256类型标识（空结构体仅作为类型标记）
#[derive(Debug, Clone, Copy)]
pub struct ShaType256;

impl ShaType for ShaType256 {
    const HASH_LEN: usize = 32;
    const STATE_LEN: usize = 8;
    const BLOCK_SIZE: usize = 64;
    type StateUnit = u32;

    fn initial_state() -> [u32; 8] {
        [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
         0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
    }
}

// SHA384类型标识
#[derive(Debug, Clone, Copy)]
pub struct ShaType384;

impl ShaType for ShaType384 {
    const HASH_LEN: usize = 48;
    const STATE_LEN: usize = 8;
    const BLOCK_SIZE: usize = 128;
    type StateUnit = u64;

    fn initial_state() -> [u64; 8] {
        [0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
         0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4]
    }
}

步骤3：实现泛型的类型状态结构体 #

基于ShaType trait的关联常量和类型，定义ShaInit、ShaUpdate、ShaFinal等泛型结构体，所有字段大小都由泛型参数trait自动推导：

// 初始化状态：标记计算未开始
pub struct ShaInit<T: ShaType>;

// 更新状态：保存当前计算上下文、未处理缓存、总长度
pub struct ShaUpdate<T: ShaType> {
    state: [T::StateUnit; T::STATE_LEN],
    buffer: [u8; T::BLOCK_SIZE],
    buffer_pos: usize,
    total_len: u64,
}

// 最终状态：保存计算完成的哈希值
pub struct ShaFinal<T: ShaType> {
    hash: [u8; T::HASH_LEN],
}

步骤4：实现状态流转逻辑 #

基于泛型结构体实现初始化、更新、最终计算的方法，所有逻辑都通过trait关联项适配不同SHA类型：

impl<T: ShaType> ShaInit<T> {
    pub fn new() -> Self {
        ShaInit
    }

    // 从初始化状态进入更新状态
    pub fn start(self) -> ShaUpdate<T> {
        ShaUpdate {
            state: T::initial_state(),
            buffer: [0u8; T::BLOCK_SIZE],
            buffer_pos: 0,
            total_len: 0,
        }
    }
}

impl<T: ShaType> ShaUpdate<T> {
    // 输入数据更新哈希状态
    pub fn update(&mut self, data: &[u8]) {
        // 这里省略具体的块处理逻辑，核心是利用T::BLOCK_SIZE等常量适配不同SHA类型
        self.total_len += data.len() as u64;
        // ... 实际的哈希计算逻辑
    }

    // 完成计算，进入最终状态
    pub fn finalize(self) -> ShaFinal<T> {
        // 省略补位、最终块计算逻辑
        ShaFinal {
            hash: [0u8; T::HASH_LEN], // 实际计算后填充哈希值
        }
    }
}

impl<T: ShaType> ShaFinal<T> {
    // 获取最终哈希值
    pub fn get_hash(&self) -> &[u8; T::HASH_LEN] {
        &self.hash
    }
}

方案优势 #

1. 仅需传递单一泛型参数T: ShaType，所有常量都从trait自动推导，无需手动传入多个const参数
2. 完全基于稳定版Rust特性（关联常量、关联类型、泛型），无需依赖nightly版本
3. 所有字段都是固定大小数组，完全符合no_std无alloc要求，无堆分配操作
4. 类型状态模式保证了状态流转的安全性，编译期就能阻止非法状态转换

内容的提问来源于stack exchange，提问作者Eugene Sh.