Prefixed API Key: Rust中安全可识别的API密钥管理库

prefixed_api_key是一个Rust库，用于生成和验证带有前缀的安全API密钥。这种密钥格式既方便识别又保证了安全性，是现代API开发的理想选择。

主要特性

• 生成带有可读前缀的API密钥
• 使用加密安全的随机数生成器
• 密钥格式：prefix_xxxxxxxxxxxxxxxx_secret_xxxxxxxxxxxxxxxx
• 支持密钥验证
• 可自定义密钥长度和前缀

安装

在Cargo.toml中添加依赖：

[dependencies]
prefixed_api_key = "0.3"

基本用法

生成新API密钥

use prefixed_api_key::PrefixedApiKey;

fn main() {
    // 生成一个新密钥
    let pak = PrefixedApiKey::generate("myapp");
    
    println!("API Key: {}", pak.to_string());
    println!("Key ID: {}", pak.key_id());
    println!("Secret: {}", pak.secret());
}

示例输出：

API Key: myapp_5Hj6u8P3Q2R9s4T7_secret_2w4z6x8y1a3b5c7d
Key ID: 5Hj6u8P3Q2R9s4T7
Secret: 2w4z6x8y1a3b5c7d

验证API密钥

use prefixed_api_key::PrefixedApiKey;

fn main() {
    let api_key = "myapp_5Hj6u8P3Q2R9s4T7_secret_2w4z6x8y1a3b5c7d";
    
    match PrefixedApiKey::parse(api_key) {
        Ok(pak) => {
            println!("Valid API key for prefix: {}", pak.prefix());
            println!("Key ID: {}", pak.key_id());
            println!("Secret: {}", pak.secret());
        }
        Err(e) => println!("Invalid API key: {}", e),
    }
}

高级用法

自定义密钥长度

use prefixed_api_key::{PrefixedApiKey, KeyConfig};

fn main() {
    let config = KeyConfig {
        prefix: "cust",
        short_key_length: 10,
        long_key_length: 20,
    };
    
    let pak = PrefixedApiKey::generate_with_config(config);
    println!("Custom API Key: {}", pak);
}

从组件构建密钥

use prefixed_api_key::PrefixedApiKey;

fn main() {
    let pak = PrefixedApiKey::from_components(
        "myapp",
        "5Hj6u8P3Q2R9s4T7",
        "2w4z6x8y1a3b5c7d",
    );
    
    println!("Reconstructed API Key: {}", pak);
}

实际应用示例

在Web服务中使用

use prefixed_api_key::PrefixedApiKey;
use actix_web::{get, App, HttpServer, HttpResponse, web};

#[get("/api/key")]
async fn generate_key() -> HttpResponse {
    let pak = PrefixedApiKey::generate("myapp");
    HttpResponse::Ok().body(pak.to_string())
}

#[get("/api/validate/{key}")]
async fn validate_key(key: web::Path<String>) -> HttpResponse {
    match PrefixedApiKey::parse(&key) {
        Ok(pak) => HttpResponse::Ok().json(serde_json::json!({
            "valid": true,
            "prefix": pak.prefix(),
            "key_id": pak.key_id()
        })),
        Err(_) => HttpResponse::BadRequest().json(serde_json::json!({
            "valid": false,
            "error": "Invalid API key format"
        })),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(generate_key)
            .service(validate_key)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

安全建议

1. 始终通过HTTPS传输API密钥
2. 不要将生成的密钥记录在日志中
3. 考虑为不同环境使用不同前缀（如dev_, prod_）
4. 定期轮换密钥

prefixed_api_key库提供了一种既安全又便于管理的API密钥解决方案，特别适合需要区分不同客户端或服务的应用场景。

完整示例代码

以下是一个完整的Rust项目示例，展示了如何使用prefixed_api_key库：

// Cargo.toml
/*
[dependencies]
prefixed_api_key = "0.3"
actix-web = "4.0"
serde_json = "1.0"
*/

// src/main.rs
use prefixed_api_key::{PrefixedApiKey, KeyConfig};
use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};
use serde_json::json;

// 生成API密钥的端点
#[get("/generate")]
async fn generate() -> impl Responder {
    let pak = PrefixedApiKey::generate("prod"); // 生产环境使用prod前缀
    HttpResponse::Ok().json(json!({
        "api_key": pak.to_string(),
        "key_id": pak.key_id(),
        "prefix": pak.prefix()
    }))
}

// 验证API密钥的端点
#[post("/validate")]
async fn validate(req_body: String) -> impl Responder {
    match PrefixedApiKey::parse(&req_body) {
        Ok(pak) => HttpResponse::Ok().json(json!({
            "valid": true,
            "prefix": pak.prefix(),
            "key_id": pak.key_id(),
            "environment": if pak.prefix() == "dev" { 
                "development" 
            } else { 
                "production" 
            }
        })),
        Err(e) => HttpResponse::BadRequest().json(json!({
            "valid": false,
            "error": e.to_string()
        })),
    }
}

// 自定义密钥生成的端点
#[get("/custom")]
async fn custom() -> impl Responder {
    let config = KeyConfig {
        prefix: "test",
        short_key_length: 12,
        long_key_length: 24,
    };
    
    let pak = PrefixedApiKey::generate_with_config(config);
    HttpResponse::Ok().body(pak.to_string())
}

// 主函数
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Starting API key server at http://localhost:8080");
    
    HttpServer::new(|| {
        App::new()
            .service(generate)
            .service(validate)
            .service(custom)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

这个示例创建了一个完整的Web服务，提供三个端点：

1. /generate - 生成新的API密钥
2. /validate - 验证API密钥的有效性
3. /custom - 生成自定义长度的API密钥

要运行这个示例：

1. 创建新的Rust项目：cargo new api_key_demo
2. 添加上述依赖到Cargo.toml
3. 将代码复制到src/main.rs
4. 运行：cargo run

测试方法：

• 访问 http://localhost:8080/generate 获取新密钥
• 使用POST请求 http://localhost:8080/validate 并发送密钥进行验证
• 访问 http://localhost:8080/custom 获取自定义长度的密钥