如何在Rust中导出已创建的ECDSA密钥对并进行存储？

针对你用p256库生成ECDSA密钥对后的导出存储需求，直接用库提供的序列化方法即可，以下是完整的导出、存储、重新导入的实用方案：

1. 导出公私钥 #

私钥（SigningKey）导出 #

SigningKey的to_bytes()方法会返回标准32字节的SECP256R1私钥数据，可转为十六进制字符串或直接保存字节流：

// 导出私钥为字节数组
let sk_bytes = signing_key.to_bytes();
// 转为十六进制字符串（方便存储/传输）
let sk_hex = hex::encode(sk_bytes);

公钥（VerifyingKey）导出 #

VerifyingKey的to_encoded_point()支持生成压缩格式（33字节，推荐）或非压缩格式（65字节）的公钥，均为行业标准格式：

// 导出压缩格式公钥
let pk_compressed = verifying_key.to_encoded_point(true);
let pk_compressed_bytes = pk_compressed.as_bytes();
let pk_compressed_hex = hex::encode(pk_compressed_bytes);

// 导出非压缩格式公钥
let pk_uncompressed = verifying_key.to_encoded_point(false);
let pk_uncompressed_bytes = pk_uncompressed.as_bytes();
let pk_uncompressed_hex = hex::encode(pk_uncompressed_bytes);

2. 存储密钥到文件 #

直接将字节或十六进制字符串写入文件即可，示例用字节流存储：

use std::fs;

// 存储私钥到文件（注意：生产环境务必加密后存储，禁止明文保存！）
fs::write("private_key.bin", sk_bytes).expect("Failed to write private key");

// 存储压缩格式公钥到文件
fs::write("public_key_compressed.bin", pk_compressed_bytes).expect("Failed to write public key");

3. 从存储中导入密钥 #

导入私钥 #

从字节数组或十六进制字符串恢复SigningKey：

// 从文件读取私钥字节
let sk_bytes = fs::read("private_key.bin").expect("Failed to read private key");
// 从字节数组恢复SigningKey
let signing_key = SigningKey::from_bytes(&sk_bytes).expect("Invalid private key");

导入公钥 #

从字节数组或十六进制字符串恢复VerifyingKey：

// 从文件读取压缩公钥字节
let pk_bytes = fs::read("public_key_compressed.bin").expect("Failed to read public key");
// 自动识别压缩/非压缩格式，恢复VerifyingKey
let verifying_key = VerifyingKey::from_sec1_bytes(&pk_bytes).expect("Invalid public key");

完整示例代码 #

结合你的原有代码，完整流程如下：

use p256::{ecdsa::{SigningKey, Signature, signature::Signer, VerifyingKey, signature::Verifier}};
use rand_core::OsRng;
use std::fs;
use hex;

fn main() {
    // 生成密钥对
    let signing_key = SigningKey::random(&mut OsRng);
    let verifying_key = VerifyingKey::from(&signing_key);
    let message = b"ECDSA proves knowledge of a secret number in the context of a single message";

    // --- 导出并存储密钥 ---
    // 导出私钥并存储
    let sk_bytes = signing_key.to_bytes();
    fs::write("private_key.bin", sk_bytes).expect("Failed to write private key");
    println!("私钥十六进制：{}", hex::encode(sk_bytes));

    // 导出压缩公钥并存储
    let pk_compressed = verifying_key.to_encoded_point(true);
    let pk_bytes = pk_compressed.as_bytes();
    fs::write("public_key.bin", pk_bytes).expect("Failed to write public key");
    println!("压缩公钥十六进制：{}", hex::encode(pk_bytes));

    // --- 从存储导入密钥并验证 ---
    // 导入私钥
    let imported_sk_bytes = fs::read("private_key.bin").unwrap();
    let imported_signing_key = SigningKey::from_bytes(&imported_sk_bytes).unwrap();
    // 导入公钥
    let imported_pk_bytes = fs::read("public_key.bin").unwrap();
    let imported_verifying_key = VerifyingKey::from_sec1_bytes(&imported_pk_bytes).unwrap();

    // 用导入的密钥完成签名验证流程
    let imported_signature = imported_signing_key.sign(message);
    assert!(imported_verifying_key.verify(message, &imported_signature).is_ok());
    println!("密钥导入验证成功！");
}

依赖说明 #

需要在Cargo.toml中添加以下依赖：

[dependencies]
p256 = { version = "0.13", features = ["ecdsa", "getrandom"] }
hex = "0.4"

关键注意事项 #

• 私钥是核心敏感数据，生产环境绝对禁止明文存储，建议用AES加密后存储，或使用操作系统密钥管理服务（如Windows CNG、macOS Keychain、Linux libsecret）。
• 公钥可安全公开存储，压缩格式体积更小，适合网络传输或嵌入式场景。

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