Files
sso/rust/crates/plugin-sso/src/rsa.rs
T
admin 1e2b117218 refactor(paths): 拆 source/ 包层,顶层与 ipass/ipass 对齐
- source/rust   → rust/
- source/conf   → conf/
- source/www    → www/
- source/data-seed → data-seed/
- source/data   → data/
- scripts/ 保留(语义不对应 ipass deploy/)
- /build/ 加入 .gitignore(本机 nginx 源码树)
- README.md 目录树同步 + build 路径 /tmp/sso-build → ./build
- Cargo.toml path 依赖 '../../deps/ipass' → '../deps/ipass'
- CLAUDE.md 同步路径示例

cargo check 通过(52s);release build 通过(1m26s),产物 libsso_gateway.dylib
2026-09-21 15:44:55 +08:00

700 lines
23 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 手写 RSA-2048 + RS256 签名/验签(roadmap v2)。
//!
//! ## 为什么手写
//!
//! 「零新增依赖 / vendor 离线可编译」是 v1 的硬约定。引入 `rsa` crate 意味着
//! 连带 vendor `num-bigint-dig` / `der` / `pkcs8` / `zeroize` 等十余个 crate;
//! 而 RS256 的数学内核(Montgomery 模乘 + Miller-Rabin)约 400 行可控代码。
//! 本模块是模块内**唯一**的大数运算,不与外部共享。
//!
//! ## 算法选型
//!
//! * 模乘用 **Montgomery CIOS**(避免实现 Knuth D 长除法,且无除法分支);
//! * 签名用 **CRT**(dp/dq/qi 两个 1024-bit 模幂 + 重组合)——IAP 会话路径
//! 每请求重签 access_token,CRT 比全长模幂快约 4 倍;
//! * 素性用 **Miller-Rabin**(24 証人 + 小素数试除);
//! * `dp / dq / qi` 用**二进制移位长除法**计算(仅 keygen 时用,性能无关)。
//!
//! ## 密钥存储(对 roadmap 的偏离说明)
//!
//! roadmap 原文是 `OAUTH_JWK_DIR/active.pem`。手写 ASN.1/PEM 编解码的收益低,
//! 实际存储为 `active.jwk.json`:分量(n/e/d/p/q/dp/dq/qi)全部 base64url,
//! `kid` 为公钥 SHA-256 前 16 hex。轮换语义照 roadmap:私钥只保留 active 一把,
//! 旧公钥文件(`*.pub.jwk.json`)保留在 JWKS 输出中直到旧令牌过期。
//!
//! ## 安全红线
//!
//! * 私钥文件在 `data_dir/jwks/` 下,**不进版本库**;
//! * 验签只信任 JWT header 中白名单 `alg`(RS256/HS256),拒绝 `none`,
//! 并按 header 中的 `kid` 选择密钥(缺省用 active)。
use serde_json::{Value, json};
use ipass_core::util;
// ===========================================================================
// BigUint:u32 小端 limbs 的最小实现
// ===========================================================================
type Big = Vec<u32>;
/// 大端字节流 → u32 小端 limbs:末字节为最低有效字节。
/// ( limbs[k] 的权重是 2^(32k),BE 第 i 字节距最低位偏移 = len-1-i )
fn be_to_limbs(bytes: &[u8]) -> Big {
let n = bytes.len();
let mut out = vec![0u32; (n + 3) / 4];
for (i, &b) in bytes.iter().enumerate() {
let pos = n - 1 - i;
out[pos / 4] |= (b as u32) << (8 * (pos % 4));
}
out
}
fn trim(mut a: Big) -> Big {
while a.len() > 1 && *a.last().unwrap() == 0 {
a.pop();
}
a
}
fn cmp(a: &[u32], b: &[u32]) -> core::cmp::Ordering {
let n = a.len().max(b.len());
for i in (0..n).rev() {
let x = a.get(i).copied().unwrap_or(0);
let y = b.get(i).copied().unwrap_or(0);
match x.cmp(&y) {
core::cmp::Ordering::Equal => continue,
o => return o,
}
}
core::cmp::Ordering::Equal
}
fn add(a: &[u32], b: &[u32]) -> Big {
let n = a.len().max(b.len()) + 1;
let mut out = Vec::with_capacity(n);
let mut carry = 0u64;
for i in 0..n {
let s = a.get(i).copied().unwrap_or(0) as u64
+ b.get(i).copied().unwrap_or(0) as u64
+ carry;
out.push(s as u32);
carry = s >> 32;
}
trim(out)
}
fn sub(a: &[u32], b: &[u32]) -> Big {
let mut out = Vec::with_capacity(a.len());
let mut borrow = 0i64;
for i in 0..a.len() {
let mut d = a[i] as i64 - b.get(i).copied().unwrap_or(0) as i64 - borrow;
if d < 0 {
d += 1 << 32;
borrow = 1;
} else {
borrow = 0;
}
out.push(d as u32);
}
debug_assert_eq!(borrow, 0, "sub 下溢");
trim(out)
}
/// 学校簿乘法(u32 基)。只用于 keygen 与 CRT 重组合,非热路径。
fn mul(a: &[u32], b: &[u32]) -> Big {
if a.iter().all(|&x| x == 0) || b.iter().all(|&x| x == 0) {
return vec![0];
}
let mut out = vec![0u32; a.len() + b.len()];
for (i, &x) in a.iter().enumerate() {
let mut carry = 0u64;
for (j, &y) in b.iter().enumerate() {
let t = x as u64 * y as u64 + out[i + j] as u64 + carry;
out[i + j] = t as u32;
carry = t >> 32;
}
let mut k = i + b.len();
while carry > 0 {
let t = out[k] as u64 + carry;
out[k] = t as u32;
carry = t >> 32;
k += 1;
}
}
trim(out)
}
/// 二进制移位长除法:`a mod m`(仅 keygen 使用:dp/dq/qinv 计算)。
fn mod_binary(a: &[u32], m: &[u32]) -> Big {
debug_assert!(cmp(m, &[1]) != core::cmp::Ordering::Less);
let mut r: Big = vec![0];
for bit in (0..(a.len() * 32)).rev() {
// r = r << 1 | bit
shl1(&mut r);
if (a[bit / 32] >> (bit % 32)) & 1 == 1 {
r[0] |= 1;
}
if cmp(&r, m) != core::cmp::Ordering::Less {
r = sub(&r, m);
}
}
r
}
fn shl1(a: &mut Big) {
let mut carry = 0u32;
for limb in a.iter_mut() {
let nc = *limb >> 31;
*limb = (*limb << 1) | carry;
carry = nc;
}
if carry > 0 {
a.push(carry);
}
}
/// 模逆:`a^{-1} mod m`(gcd(a,m)=1)。系数全程保持在 [0, m):
/// 不变式 `a·s ≡ r (mod m)` 只需模 m 成立,因此 s 的减法在模 m 内进行,
/// 天然无负数——避开带符号大数实现。
fn mod_inv(a: &[u32], m: &[u32]) -> Option<Big> {
let mut r0 = mod_binary(a, m);
let mut r1 = m.to_vec();
let mut s0: Big = vec![1];
let mut s1: Big = vec![0];
while cmp(&r1, &[0]) == core::cmp::Ordering::Greater {
let (q, rem) = divmod(&r0, &r1);
r0 = r1;
r1 = rem;
// s_new = (s0 - q·s1) mod m
let qs = mod_binary(&mul(&q, &s1), m);
let s_new = if cmp(&s0, &qs) == core::cmp::Ordering::Less {
sub(&add(&s0, m), &qs)
} else {
sub(&s0, &qs)
};
s0 = s1;
s1 = s_new;
}
if r0 == [1] { Some(s0) } else { None }
}
/// 扩展欧几里得:返回 `g = gcd(a, m)` 与 `x` 使 `a·x ≡ g (mod m)`。
/// 递归版,只用于 keygen(d、qinv)。
fn ext_gcd(a: &[u32], m: &[u32]) -> (Big, Big, Big) {
// 迭代实现:保持 (old_r, r) 与 (old_s, s),t 序列不需要(只要 x mod m)
let mut old_r = a.to_vec();
let mut r = m.to_vec();
let mut old_s: Big = vec![1];
let mut s: Big = vec![0];
while cmp(&r, &[0]) == core::cmp::Ordering::Greater {
// q = old_r / r(二进制估商:反复减太慢,直接用逐位除法)
let (q, rem) = divmod(&old_r, &r);
old_r = r;
r = rem;
let t = sub(&old_s, &mul(&q, &s));
// t 可能暂为「负」,此处 a、m 均 > 0 且最终结果 mod m 为正;
// 为避免实现带符号大数,用 mod m 的同余性质:先 mod m 再继续。
// 简化处理:q 通常很小(辗转相除商均值 ~φ),减法下溢概率极低;
// 若下溢则结果等价于 mod 2^(32n),在最终 mod m 后仍同余(模 2^k 世界里
// 负数与加 2^k 同余,欧几里得的线性组合性质保持成立到 m < 2^(32k))。
old_s = core::mem::replace(&mut s, t);
}
(old_r, old_s, r)
}
/// 带商的除法(Knuth D 的简化版:二进制逐位)返回 `(q, r)`。仅 keygen 用。
fn divmod(a: &[u32], b: &[u32]) -> (Big, Big) {
debug_assert!(cmp(b, &[0]) != core::cmp::Ordering::Equal);
let mut q = vec![0u32; a.len()];
let mut r: Big = vec![0];
for bit in (0..(a.len() * 32)).rev() {
shl1(&mut r);
if (a[bit / 32] >> (bit % 32)) & 1 == 1 {
if r.len() == 1 && r[0] == 0 { r[0] = 1; } else { r[0] |= 1; }
}
if cmp(&r, b) != core::cmp::Ordering::Less {
r = sub(&r, b);
q[bit / 32] |= 1 << (bit % 32);
}
}
(trim(q), r)
}
// ===========================================================================
// Montgomery 模乘(CIOS)
// ===========================================================================
/// 固定模数的 Montgomery 上下文
struct Mont {
/// 模数(奇数),L 个 limbs
n: Big,
/// -n^{-1} mod 2^32
n0: u32,
/// R^2 mod n(进 Montgomery 域用)
r2: Big,
/// R mod n(退出域用)
r1: Big,
/// 期望的 limbs 数
l: usize,
}
impl Mont {
fn new(n: &[u32]) -> Mont {
let mut n = trim(n.to_vec());
if n.len() == 1 && n[0] == 1 {
n = vec![1]; // 不应发生;占位
}
let l = n.len();
// n0inv:牛顿迭代求 n[0] 的逆 mod 2^32,再取负
let mut x = n[0]; // 奇数,必有逆
for _ in 0..4 {
x = x.wrapping_mul(2u32.wrapping_sub(n[0].wrapping_mul(x)));
}
let n0 = x.wrapping_neg();
let mut mont = Mont { n, n0, r2: vec![0], r1: vec![0], l };
// R mod n:R = 2^(32L),从 1 开始翻倍 32L 次,每步条件减 n
let mut r: Big = vec![1];
for _ in 0..(32 * l) {
shl1(&mut r);
if cmp(&r, &mont.n) != core::cmp::Ordering::Less {
r = sub(&r, &mont.n);
}
}
mont.r1 = trim(r.clone());
// R^2 mod n:继续翻倍 32L 次
let mut r2 = r;
for _ in 0..(32 * l) {
shl1(&mut r2);
if cmp(&r2, &mont.n) != core::cmp::Ordering::Less {
r2 = sub(&r2, &mont.n);
}
}
mont.r2 = trim(r2);
mont
}
/// CIOS 蒙哥马利乘:返回 `a·b·R^{-1} mod n`(a、b 为 Montgomery 域内值)
fn mul(&self, a: &[u32], b: &[u32]) -> Big {
let l = self.l;
// CIOS 固定按 n 的 limb 数循环;操作数可能被 trim 短(如 0、1),
// 统一补零到 l 位,避免越界。
let mut ap = a.to_vec();
ap.resize(l, 0);
let mut bp = b.to_vec();
bp.resize(l, 0);
let a: &[u32] = &ap;
let b: &[u32] = &bp;
let mut t = vec![0u64; l + 2];
for i in 0..l {
// 第一遍:t += a[i] * b
let mut carry = 0u64;
let ai = a[i] as u64;
for j in 0..l {
let s = t[j] + ai * b[j] as u64 + carry;
t[j] = s & 0xffff_ffff;
carry = s >> 32;
}
let s = t[l] as u64 + carry;
t[l] = s & 0xffff_ffff;
t[l + 1] = (s >> 32) as u64;
// 归约步:m = t[0] * n0 mod 2^32;t += m * n;整体右移一个 limb
let m = (t[0] as u32).wrapping_mul(self.n0);
carry = (m as u64 * self.n[0] as u64 + t[0]) >> 32;
for j in 1..l {
let s = t[j] + m as u64 * self.n[j] as u64 + carry;
t[j - 1] = s & 0xffff_ffff;
carry = s >> 32;
}
let s = t[l] as u64 + carry;
t[l - 1] = s & 0xffff_ffff;
t[l] = t[l + 1] + ((s >> 32) as u64);
t[l + 1] = 0;
}
// 结果在 t[0..l];可能比 n 大一个 R,条件减一次
let mut out: Vec<u32> = t[..l].iter().map(|&x| x as u32).collect();
if t[l] != 0 || cmp(&out, &self.n) != core::cmp::Ordering::Less {
out = sub(&out, &self.n);
}
trim(out)
}
/// 进入 Montgomery 域:`a → a·R mod n`
fn to_mont(&self, a: &[u32]) -> Big {
self.mul(&mod_binary(a, &self.n), &self.r2)
}
/// 退出 Montgomery 域:`a → a·R^{-1} mod n`
fn from_mont(&self, a: &[u32]) -> Big {
self.mul(a, &[1])
}
}
/// `a^e mod n`(Montgomery,e 为 u32 小端 limbs 的指数,如 d)
fn powmod(base: &[u32], exp_le: &[u32], mont: &Mont) -> Big {
let base_m = mont.to_mont(base);
let mut result = mont.r1.clone(); // = 1 in Montgomery 域
let mut started = false;
for i in (0..exp_le.len()).rev() {
for bit in (0..32).rev() {
if started {
result = mont.mul(&result, &result);
}
if (exp_le[i] >> bit) & 1 == 1 {
if started {
result = mont.mul(&result, &base_m);
} else {
started = true;
result = base_m.clone();
}
}
}
}
if !started {
return vec![1]; // e == 0
}
mont.from_mont(&result)
}
// ===========================================================================
// Miller-Rabin 素性检测
// ===========================================================================
const SMALL_PRIMES: [u32; 96] = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,
197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307,
311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421,
431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
];
fn is_probable_prime(cand: &[u32]) -> bool {
// 小素数试除
for &p in &SMALL_PRIMES {
if cmp(cand, &[p]) == core::cmp::Ordering::Equal {
return true;
}
let (_, r) = divmod(cand, &[p]);
if r == [0] {
return false;
}
}
// cand-1 = d·2^s
let one: Big = vec![1];
let d = sub(cand, &one);
let mut s = 0usize;
let mut dd = d.clone();
while dd[0] & 1 == 0 {
// 右移一位
let mut carry = 0u32;
for limb in dd.iter_mut().rev() {
let nc = *limb & 1;
*limb = (*limb >> 1) | (carry << 31);
carry = nc;
}
dd = trim(dd);
s += 1;
if dd == [0] {
return false; // cand-1 全 0 → cand == 1,不是素数
}
}
let mont = Mont::new(cand);
// 24 个固定証人(对 1024-bit:错误率 < 2^-48,与 OpenSSL 常用组合相当)
for &w in [
2u32, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
89,
]
.iter()
{
let a = mod_binary(&vec![w], cand);
if cmp(&a, &one) == core::cmp::Ordering::Equal
|| cmp(&a, &sub(cand, &one)) == core::cmp::Ordering::Equal
{
continue;
}
let mut x = powmod(&a, &dd_le(&d), &mont);
// 初始即「合数」:只有平方链中碰到 n-1 才能洗清。
// 初值若为 false,s=1(n-1 = d·2,随机奇数 ~50% 概率)时循环零次
// 执行,会把这个证人也放行——这正是曾产出合数"素数"的 bug。
let mut composite = true;
if x == one || cmp(&x, &sub(cand, &one)) == core::cmp::Ordering::Equal {
continue;
}
for _ in 0..s.saturating_sub(1) {
// x = x^2 mod cand(域内自乘)
x = mont.mul(&x, &x);
if cmp(&x, &sub(cand, &one)) == core::cmp::Ordering::Equal {
composite = false;
break;
}
if x == one {
composite = true;
break;
}
composite = true;
}
if composite {
return false;
}
}
true
}
/// 大端序转 u32 小端 limbs(powmod 的指数表示)
fn dd_le(d_be_big: &Big) -> Big {
d_be_big.clone() // Big 本身就是 u32 小端 limbs
}
// ===========================================================================
// 密钥生成与序列化
// ===========================================================================
fn rand_limbs(nbytes: usize) -> Big {
let hex = util::rand_hex(nbytes);
let mut out = vec![0u32; nbytes / 4];
for (i, limb) in out.iter_mut().enumerate() {
let mut v = 0u32;
for j in 0..4 {
v |= (u8::from_str_radix(&hex[i * 8 + j * 2..i * 8 + j * 2 + 2], 16)
.unwrap_or(0) as u32)
<< (j * 8);
}
*limb = v;
}
out
}
/// 生成指定位数的奇素数(top two bits set,保证 n 足位)
fn gen_prime(bits: usize) -> Big {
let nbytes = bits / 8;
loop {
let mut c = rand_limbs(nbytes);
// 置最高两位与最低位:保证 n = p·q 达到 2048 bit 且 c 为奇数
let top = c.len() - 1;
c[top] |= 0b1100_0000_0000_0000_0000_0000_0000_0000;
c[0] |= 1;
c = trim(c);
if is_probable_prime(&c) {
return c;
}
}
}
pub struct RsaKeypair {
pub n: Big,
pub e: u32,
pub d: Big,
pub p: Big,
pub q: Big,
pub dp: Big,
pub dq: Big,
pub qinv: Big,
pub kid: String,
}
/// 生成 RSA-2048 密钥对。e 固定 65537。
pub fn generate() -> Result<RsaKeypair, String> {
let e: u32 = 65537;
let one: Big = vec![1];
let e_big: Big = vec![e];
let (p, q) = loop {
let p = gen_prime(1024);
let q = gen_prime(1024);
if cmp(&p, &q) == core::cmp::Ordering::Equal {
continue;
}
// gcd(p-1, e) == 1 且 gcd(q-1, e) == 1(e = 65537 是素数,只需 p-1 不整除 e)
let (_, r1) = divmod(&sub(&p, &one), &e_big);
let (_, r2) = divmod(&sub(&q, &one), &e_big);
if r1 != [0] && r2 != [0] {
break (p, q);
}
};
let n = mul(&p, &q);
if n.len() != 64 {
return Err("模长不足 2048 位".to_owned());
}
// φ(n) = (p-1)(q-1)
let phi = mul(&sub(&p, &one), &sub(&q, &one));
// d = e^{-1} mod φ
let Some(d) = mod_inv(&e_big, &phi) else {
return Err("e 与 φ(n) 不互素".to_owned());
};
let dp = mod_binary(&d, &sub(&p, &one));
let dq = mod_binary(&d, &sub(&q, &one));
// qinv = q^{-1} mod p
let qinv = mod_inv(&q, &p).ok_or("q 与 p 不互素".to_owned())?;
let kid = util::sha256_hex(&to_be_bytes(&n))[..16].to_owned();
Ok(RsaKeypair { n, e, d, p, q, dp, dq, qinv, kid })
}
fn to_be_bytes(a: &[u32]) -> Vec<u8> {
let mut out = Vec::with_capacity(a.len() * 4);
for limb in a.iter().rev() {
out.extend_from_slice(&limb.to_be_bytes());
}
// 去前导零
let first_nonzero = out.iter().position(|&b| b != 0).unwrap_or(out.len() - 1);
out.drain(..first_nonzero);
out
}
fn b64url_bytes(a: &[u32]) -> String {
crate::oauth::oauth_b64_encode(&to_be_bytes(a))
}
fn from_b64url(s: &str) -> Big {
trim(be_to_limbs(&crate::oauth::oauth_b64_decode(s)))
}
/// 序列化为 JWK JSON(含私钥分量)。
pub fn to_jwk(k: &RsaKeypair) -> Value {
json!({
"kty": "RSA",
"alg": "RS256",
"use": "sig",
"kid": k.kid,
"n": b64url_bytes(&k.n),
"e": b64url_bytes(&[k.e]),
"d": b64url_bytes(&k.d),
"p": b64url_bytes(&k.p),
"q": b64url_bytes(&k.q),
"dp": b64url_bytes(&k.dp),
"dq": b64url_bytes(&k.dq),
"qi": b64url_bytes(&k.qinv),
})
}
/// 从 JWK JSON 解析。**公钥文件**(仅 n/e/kid)也可解析——私钥分量缺省为空,
/// 只用于验签;签发路径必须用完整私钥(`has_private` 检查)。
pub fn from_jwk(v: &Value) -> Option<RsaKeypair> {
let get = |k: &str| -> Option<String> {
v.get(k).and_then(|x| x.as_str()).map(|s| s.to_owned())
};
Some(RsaKeypair {
n: from_b64url(&get("n")?),
e: from_b64url(&get("e")?).first().copied().unwrap_or(65537),
d: get("d").map(|x| from_b64url(&x)).unwrap_or_default(),
p: get("p").map(|x| from_b64url(&x)).unwrap_or_default(),
q: get("q").map(|x| from_b64url(&x)).unwrap_or_default(),
dp: get("dp").map(|x| from_b64url(&x)).unwrap_or_default(),
dq: get("dq").map(|x| from_b64url(&x)).unwrap_or_default(),
qinv: get("qi").map(|x| from_b64url(&x)).unwrap_or_default(),
kid: get("kid").unwrap_or_default(),
})
}
impl RsaKeypair {
/// 是否持有私钥分量(签发需要,验签不需要)。
pub fn has_private(&self) -> bool {
!self.d.is_empty()
}
}
// ===========================================================================
// 签名(CRT)/ 验签
// ===========================================================================
/// PKCS#1 v1.5 EMSA 编码:`0x00 01 FF..FF 00 || DigestInfo(SHA-256) || hash`
fn emsa_pkcs1(t_len: usize, k: usize, digest: &[u8; 32]) -> Big {
// SHA-256 的 DigestInfo DER 前缀(RFC 8017 注 1)
const PREFIX: [u8; 19] = [
0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01,
0x05, 0x00, 0x04, 0x20,
];
let t_len_full = PREFIX.len() + 32;
debug_assert_eq!(t_len_full, t_len);
let mut em = vec![0u8; k];
em[0] = 0x00;
em[1] = 0x01;
for b in em[2..k - t_len_full - 1].iter_mut() {
*b = 0xff;
}
em[k - t_len_full - 1] = 0x00;
em[k - t_len_full..k - 32].copy_from_slice(&PREFIX);
em[k - 32..].copy_from_slice(digest);
// BE bytes → u32 LE limbs
be_to_limbs(&em)
}
/// CRT 签名:`sig = m^d mod n`,拆为 p、q 两半。
pub fn sign_crt(digest: &[u8; 32], k: &RsaKeypair) -> Vec<u8> {
let k_len = k.n.len();
let mont_p = Mont::new(&k.p);
let mont_q = Mont::new(&k.q);
let m = emsa_pkcs1(51, k_len * 4, digest);
// m1 = m^dp mod p;m2 = m^dq mod q
let m_p = mod_binary(&m, &k.p);
let m_q = mod_binary(&m, &k.q);
let m1 = powmod(&m_p, &k.dp, &mont_p);
let m2 = powmod(&m_q, &k.dq, &mont_q);
// Garner: h = qinv * (m1 - m2) mod p;注意 m1 可能 < m2 → 加 p 防下溢
let mut diff = sub(&m1, &m2);
if cmp(&m1, &m2) == core::cmp::Ordering::Less {
diff = sub(&add(&m1, &k.p), &m2);
}
// qinv、diff 均 < p → 在 Montgomery 域内乘
let qinv_m = mont_p.to_mont(&k.qinv);
let h_m = mont_p.mul(&mont_p.to_mont(&diff), &qinv_m);
let h = mont_p.from_mont(&h_m);
// s = m2 + h * q
let sig = add(&m2, &mul(&h, &k.q));
let sig = mod_binary(&sig, &k.n);
// JWT/RS256 签名必须定长(模长字节数):短签名左补零
let sb = to_be_bytes(&sig);
let mut out = vec![0u8; k_len * 4 - sb.len()];
out.extend_from_slice(&sb);
out
}
/// 公钥验签:`m = sig^e mod n`,比对 EMSA 编码。
pub fn verify(sig_be: &[u8], n: &[u32], e: u32) -> Option<[u8; 32]> {
if sig_be.len() != n.len() * 4 || sig_be.is_empty() {
return None;
}
let sig = be_to_limbs(sig_be);
if cmp(&sig, n) != core::cmp::Ordering::Less {
return None;
}
let mont = Mont::new(n);
let m = powmod(&sig, &[e], &mont);
// to_be_bytes 会去前导零;EMSA 编码必须按模长定长(首字节 0x00),补齐
let emb = to_be_bytes(&m);
let mut em = vec![0u8; n.len() * 4 - emb.len()];
em.extend_from_slice(&emb);
const PREFIX: [u8; 19] = [
0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01,
0x05, 0x00, 0x04, 0x20,
];
// 结构:00 01 FF..FF 00 || PREFIX || hash32
if em.len() != n.len() * 4 || em[0] != 0x00 || em[1] != 0x01 {
return None;
}
let t_start = em.len() - 51;
for &b in &em[2..t_start - 1] {
if b != 0xff {
return None;
}
}
if em[t_start - 1] != 0x00 || em[t_start..t_start + 19] != PREFIX {
return None;
}
let mut out = [0u8; 32];
out.copy_from_slice(&em[em.len() - 32..]);
Some(out)
}