Rust开发AES库时如何避免大量样板代码？

针对你遇到的const泛型组合导致impl块爆炸的问题，有几种实用的解决方案，以下是具体实现：

方案1：用声明宏批量生成impl块 #

如果你的密钥大小和填充方案是固定的有限组合，声明宏可以自动帮你生成所有需要的impl块，无需手动重复编写。

步骤示例： #

1. 定义填充方式的标记trait：

pub trait Padding {}
pub struct NoPadding;
pub struct Pkcs7Padding;
pub struct Iso10126Padding;

impl Padding for NoPadding {}
impl Padding for Pkcs7Padding {}
impl Padding for Iso10126Padding {}

2. 编写宏生成所有组合的impl：

macro_rules! impl_aes_key_logic {
    // 语法：密钥参数列表; 填充类型列表
    ($($n:expr => $round_keys:expr),*; $($padding:ty),*) => {
        $(
            $(
                // 实现AesKeyOps trait
                impl AesKeyOps<$n, $round_keys> for AesKey<$n>
                where
                    $padding: Padding,
                {
                    fn expand_key(&self) -> [u32; $round_keys] {
                        // 这里编写通用的密钥扩展逻辑，依赖$n和$round_keys
                        unimplemented!()
                    }

                    // 实现其他trait方法...
                }

                // 实现填充相关的trait（比如BlockCipherWithPadding）
                impl BlockCipherWithPadding<$padding> for AesKey<$n> {
                    fn pad_block(&self, block: &mut [u8]) {
                        <$padding as Padding>::pad(block)
                    }

                    fn unpad_block(&self, block: &[u8]) -> Result<&[u8], PaddingError> {
                        <$padding as Padding>::unpad(block)
                    }
                }
            )*
        )*
    };
}

// 调用宏生成3种密钥大小×3种填充的所有组合
impl_aes_key_logic! {
    4 => 11, 6 => 13, 8 => 15;
    NoPadding, Pkcs7Padding, Iso10126Padding
}

方案2：用标记trait+关联常量约束合法参数 #

通过标记trait封装密钥大小的参数关联，让trait bound自动覆盖所有合法组合，无需为每个const值单独写impl。

步骤示例： #

1. 定义密钥大小的标记trait，包含关联常量：

pub trait AesKeySize {
    const N: usize;          // 密钥的u32数组长度
    const N_ROUND_KEYS: usize; // 轮密钥数量
}

pub struct Aes128;
impl AesKeySize for Aes128 {
    const N: usize = 4;
    const N_ROUND_KEYS: usize = 11;
}

pub struct Aes192;
impl AesKeySize for Aes192 {
    const N: usize = 6;
    const N_ROUND_KEYS: usize = 13;
}

pub struct Aes256;
impl AesKeySize for Aes256 {
    const N: usize = 8;
    const N_ROUND_KEYS: usize = 15;
}

2. 修改AesKey结构体，使用标记trait作为泛型参数：

pub struct AesKey<S: AesKeySize> {
    data: [u32; S::N],
}

3. 一次性实现所有合法组合的trait：

// 为所有AesKeySize和Padding组合实现AesKeyOps
impl<S: AesKeySize, P: Padding> AesKeyOps<S::N, S::N_ROUND_KEYS> for AesKey<S> {
    fn expand_key(&self) -> [u32; S::N_ROUND_KEYS] {
        // 通用密钥扩展逻辑，复用S的关联常量
        unimplemented!()
    }
}

// 实现填充相关trait
impl<S: AesKeySize, P: Padding> BlockCipherWithPadding<P> for AesKey<S> {
    fn pad_block(&self, block: &mut [u8]) {
        <P as Padding>::pad(block)
    }

    fn unpad_block(&self, block: &[u8]) -> Result<&[u8], PaddingError> {
        <P as Padding>::unpad(block)
    }
}

这种方式扩展性极好，后续新增密钥大小或填充方式，只需新增对应的标记trait实现即可。

方案3：用const泛型的where约束关联参数 #

如果不想修改AesKey的原有const泛型结构，可通过trait将N和N_ROUND_KEYS关联，用where约束过滤合法的const值：

步骤示例： #

1. 定义关联密钥参数的trait：

pub trait ValidAesKeySize<const N: usize> {
    const N_ROUND_KEYS: usize;
}

// 为合法的N值实现该trait
impl ValidAesKeySize<4> for () {
    const N_ROUND_KEYS: usize = 11;
}

impl ValidAesKeySize<6> for () {
    const N_ROUND_KEYS: usize = 13;
}

impl ValidAesKeySize<8> for () {
    const N_ROUND_KEYS: usize = 15;
}

2. 实现trait时通过where约束限定合法N：

// 覆盖所有合法N和Padding组合
impl<const N: usize, P: Padding> AesKeyOps<N, <() as ValidAesKeySize<N>>::N_ROUND_KEYS> for AesKey<N>
where
    (): ValidAesKeySize<N>, // 仅允许合法的N值
{
    fn expand_key(&self) -> [u32; <() as ValidAesKeySize<N>>::N_ROUND_KEYS] {
        unimplemented!()
    }
}

impl<const N: usize, P: Padding> BlockCipherWithPadding<P> for AesKey<N>
where
    (): ValidAesKeySize<N>,
{
    fn pad_block(&self, block: &mut [u8]) {
        <P as Padding>::pad(block)
    }

    fn unpad_block(&self, block: &[u8]) -> Result<&[u8], PaddingError> {
        <P as Padding>::unpad(block)
    }
}

这种方式保留了原有const泛型的设计，同时避免了重复编写impl块。

内容的提问来源于stack exchange，提问作者Federico Fusco