- 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
700 lines
23 KiB
Rust
700 lines
23 KiB
Rust
//! 手写 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] = ≈
|
||
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)
|
||
}
|