Rust中如何使用[u8; 64]数组为加密安全RNG引擎设置种子？

64字节BIP39种子处理 #

首先不需要专门找支持64字节种子的加密安全RNG，现有方案可以直接适配：
你可以用密码学安全的哈希函数把64字节的BIP39种子压缩为32字节，作为ChaCha系列RNG的输入，不会损失熵，也完全符合安全要求，代码示例如下：

use sha2::{Sha256, Digest};
use chacha20::ChaCha20Rng;
use rand_core::SeedableRng;

// 从助记词拿到64字节种子后
let seed_bytes = seed.as_bytes();
let chacha_seed: [u8; 32] = Sha256::digest(seed_bytes).into();
let mut rng = ChaCha20Rng::from_seed(chacha_seed);

你之前用到的HmacDRBG本身也支持任意长度的种子输入，也是合规的方案。

复现node-forge RSA生成逻辑 #

你当前生成的密钥不符合预期，问题不在于RNG选型，而在于Rust RSA库默认的素数生成逻辑和node-forge的自定义规则不一致，需要手动实现对齐node-forge的素数生成逻辑，再手动构造RSA私钥：

1. 首先实现符合node-forge规则的素数生成函数：

use num_bigint::{BigUint, RandomBits};
use num_traits::{One, BitOr};
use rand::Rng;

const THIRTY: BigUint = BigUint::from(30u8);

fn generate_forge_compatible_prime(bits: usize, rng: &mut impl Rng) -> BigUint {
    loop {
        // 生成指定位数的随机大整数
        let mut num: BigUint = rng.sample(RandomBits::new(bits as u64));
        let highest_bit = bits - 1;
        // 强制最高位为1，保证素数长度符合要求
        if !num.bit(highest_bit) {
            num = num | (BigUint::one() << highest_bit);
        }
        // 对齐到30k+1边界，和node-forge逻辑一致
        let mod_30 = &num % &THIRTY;
        let offset = 31 - mod_30.to_u8().unwrap();
        num += offset;
        // 素性测试轮次和node-forge保持一致
        if num.is_probable_prime(64) {
            return num;
        }
    }
}

2. 手动构造RSA私钥，不要使用RsaPrivateKey::new默认方法：

// Arweave JWK采用4096位模数，拆分为两个2048位素数
let p = generate_forge_compatible_prime(2048, &mut rng);
let q = generate_forge_compatible_prime(2048, &mut rng);
// 公钥指数固定为65537，和Arweave规范一致
let e = BigUint::from(65537u32);
let n = &p * &q;
let phi = (&p - BigUint::one()) * (&q - BigUint::one());
let d = e.mod_inverse(&phi).unwrap();
let dp = &d % (&p - BigUint::one());
let dq = &d % (&q - BigUint::one());
let qinv = q.mod_inverse(&p).unwrap();

// 将以上参数按大端序转为字节数组，填入你的JWK结构体即可

注意事项 #

• 你之前代码里的模数长度4098是笔误，需要改为4096才能符合Arweave的JWK规范
• 转换大整数为字节数组时，要确认使用大端序，和Arweave的字节序要求一致

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