Rust 中的 EdDSA 与 RS256 签名算法详解：原理、对比及实例代码

摘要
在 Web 认证和授权中，JSON Web Token (JWT) 是一种常用的方式，而选择合适的签名算法尤为关键。本文将详细介绍 EdDSA 和 RS256 两种常用签名算法的原理、优缺点及适用场景，并使用 Rust 代码实现基于 JWT 的签名与验证。希望本文能帮助开发者理解和应用这两种算法的特性，在项目中做出最优的选择。

一、背景与简介

EdDSA（Edwards-Curve Digital Signature Algorithm）和RS256（RSA + SHA-256）都是广泛应用的数字签名算法。EdDSA 采用 Edwards 曲线（如 Ed25519 和 Ed448），其设计初衷是提升签名速度和抗侧信道攻击能力。而 RS256 则基于传统的 RSA 算法，使用 SHA-256 作为哈希函数，适合需要公私钥对分离的场景。

使用场景概述：

• EdDSA：适合对性能和带宽有较高要求的设备和应用（如物联网和实时通信）。
• RS256：适合需要公钥共享、跨平台或服务器端认证的复杂系统（如分布式系统和 OAuth2 认证）。

接下来，我们将从原理、对比、适用场景及代码实例几个方面来深入探讨这两种算法。

二、算法原理与特性

1. EdDSA 原理与特性

EdDSA 使用椭圆曲线数字签名算法，通常基于两种曲线：

• Ed25519：提供 128 位的安全性，密钥长度为 256 位。
• Ed448：提供 224 位的安全性，密钥长度为 456 位。

EdDSA 是一个确定性签名算法，给定相同的输入和私钥，每次签名生成的结果是相同的。其核心特点包括：

• 签名速度快，适合低延迟应用。
• 抗侧信道攻击能力强，安全性高。
• 密钥和签名短，减少了数据传输的负担。

2. RS256 原理与特性

RS256 基于 RSA 和 SHA-256，是一种传统的非对称签名算法。RSA 密钥长度一般为 2048 位或更长，以确保较高的安全性。RS256 的核心特性包括：

• 广泛支持，许多现有系统都支持 RSA 公钥和私钥。
• 安全性高，适合对安全性有较高需求的场景。
• 签名较长，传输成本高于 EdDSA。

3. 对比与总结

三、适用场景分析

EdDSA

EdDSA 的设计更适合对计算资源和带宽有限的场景，如：

1. 物联网设备：设备资源受限，签名速度快且占用带宽小。
2. 实时消息传输：如视频通信等实时性要求高的应用场景。

RS256

RS256 更适合需要强兼容性、支持公私钥对分离的复杂应用，如：

1. 服务器认证：公钥和私钥分离，适合复杂服务器认证需求。
2. 分布式系统：RSA 公钥广泛支持，适合跨平台和跨系统的通信验证。

四、Rust 实现 EdDSA 与 RS256 签名与验证

接下来，我们分别使用 EdDSA (Ed25519) 和 RS256 两种算法来实现 JWT 的签名和验证。我们使用jsonwebtoken库生成和解析 JWT，结合ring库实现 EdDSA 签名，以及rsa库实现 RS256 签名。

1. 使用 EdDSA (Ed25519) 生成和验证 JWT

依赖库

在Cargo.toml文件中添加以下依赖：

[dependencies]
jsonwebtoken = "7.2"
ring = "0.16.20"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

EdDSA 实现代码

use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey, Algorithm, TokenData};
use ring::signature::{Ed25519KeyPair, KeyPair};
use serde::{Serialize, Deserialize};
use std::fs;

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,
    company: String,
    exp: usize,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 读取私钥并创建密钥对
    let private_key_bytes = fs::read("ed25519_private_key.der")?;
    let key_pair = Ed25519KeyPair::from_pkcs8(&private_key_bytes)?;
    let encoding_key = EncodingKey::from_ed_der(&private_key_bytes);

    // 2. 创建 payload 数据
    let my_claims = Claims {
        sub: "example".to_owned(),
        company: "myCompany".to_owned(),
        exp: 10000000000,
    };

    // 3. 使用 EdDSA 签名生成 JWT
    let token = encode(&Header::new(Algorithm::EdDSA), &my_claims, &encoding_key)?;
    println!("Generated JWT: {}", token);

    // 4. 使用公钥验证 JWT
    let public_key_bytes = fs::read("ed25519_public_key.der")?;
    let decoding_key = DecodingKey::from_ed_der(&public_key_bytes);
    let token_data: TokenData<Claims> = decode(&token, &decoding_key, &Validation::new(Algorithm::EdDSA))?;

    println!("Decoded JWT claims: {:?}", token_data.claims);
    Ok(())
}

2. 使用 RS256 生成和验证 JWT

依赖库

在Cargo.toml文件中添加以下依赖：

[dependencies]
jsonwebtoken = "7.2"
rsa = "0.6.0"
rand = "0.8"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

RS256 实现代码

use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey, Algorithm, TokenData};
use rsa::{RSAPrivateKey, PaddingScheme};
use serde::{Serialize, Deserialize};
use std::fs;

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,
    company: String,
    exp: usize,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 读取 RSA 私钥以生成 JWT 签名
    let private_key_pem = fs::read_to_string("rsa_private.pem")?;
    let encoding_key = EncodingKey::from_rsa_pem(private_key_pem.as_bytes())?;

    // 2. 创建 payload 数据
    let my_claims = Claims {
        sub: "example".to_owned(),
        company: "myCompany".to_owned(),
        exp: 10000000000,
    };

    // 3. 使用 RSA 私钥生成 JWT
    let token = encode(&Header::new(Algorithm::RS256), &my_claims, &encoding_key)?;
    println!("Generated JWT: {}", token);

    // 4. 验证 JWT 签名
    let public_key_pem = fs::read_to_string("rsa_public.pem")?;
    let decoding_key = DecodingKey::from_rsa_pem(public_key_pem.as_bytes())?;
    let token_data: TokenData<Claims> = decode(&token, &decoding_key, &Validation::new(Algorithm::RS256))?;

    println!("Decoded JWT claims: {:?}", token_data.claims);
    Ok(())
}

五、总结

在现代 Web 应用中，选择合适的签名算法需要根据性能、安全性和兼容性综合考量。EdDSA的高效性和小密钥特性适合资源有限的设备和实时通信

场景，而RS256的强兼容性和安全性适合复杂的认证系统。希望通过本文和 Rust 示例代码，开发者能更好地理解和实现这两种算法，以适应不同应用需求。