Rust认证与授权库boringauth使用指南

简介

boringauth是一个专注于简化Rust应用程序中用户认证和授权流程的库。它提供了开箱即用的解决方案来处理用户登录、权限验证和访问控制，让开发者能够快速实现安全功能而不用从头构建复杂的认证系统。

主要特性

• 简单的用户认证流程
• 基于角色的访问控制(RBAC)
• JWT(JSON Web Tokens)支持
• 密码哈希和验证
• 可扩展的权限系统

安装

在Cargo.toml中添加依赖：

[dependencies]
boringauth = "0.3"

基本使用方法

1. 用户认证

use boringauth::{AuthManager, PasswordHasher, UserCredentials};

let auth_manager = AuthManager::new();
let hasher = PasswordHasher::default();

// 用户注册
let credentials = UserCredentials {
    username: "user123".to_string(),
    password: "securepassword".to_string(),
};

let hashed_password = hasher.hash(&credentials.password).unwrap();
auth_manager.register_user(&credentials.username, &hashed_password).unwrap();

// 用户登录
let login_result = auth_manager.authenticate(&credentials.username, "securepassword");
match login_result {
    Ok(token) => println!("Login successful! Token: {}", token),
    Err(e) => println!("Login failed: {}", e),
}

2. 基于角色的权限控制

use boringauth::{AuthManager, Role, Permission};

let mut auth_manager = AuthManager::new();

// 定义角色和权限
let admin_role = Role::new("admin")
    .with_permission(Permission::new("create_user"))
    .with_permission(Permission::new("delete_user"));

let user_role = Role::new("user")
    .with_permission(Permission::new("view_profile"));

// 注册角色
auth_manager.register_role(admin_role);
auth_manager.register_role(user_role);

// 为用户分配角色
auth_manager.assign_role("user123", "admin").unwrap();

// 检查权限
if auth_manager.has_permission("user123", "delete_user") {
    println!("User has delete permission");
}

3. JWT令牌验证

use boringauth::{JwtValidator, JwtConfig};

let config = JwtConfig::new("your-secret-key".to_string())
    .with_expiry(3600); // 1小时有效期

let validator = JwtValidator::new(config);

// 生成令牌
let claims = HashMap::from([("username", "user123")]);
let token = validator.generate_token(claims).unwrap();

// 验证令牌
match validator.validate_token(&token) {
    Ok(decoded_claims) => {
        println!("Valid token for user: {}", decoded_claims["username"]);
    },
    Err(e) => println!("Invalid token: {}", e),
}

高级用法

自定义密码哈希器

use boringauth::{PasswordHasher, Argon2Config};

let config = Argon2Config::new()
    .time_cost(3)
    .memory_cost(65536)
    .parallelism(4);

let custom_hasher = PasswordHasher::with_config(config);

中间件集成(以Actix-web为例)

use actix_web::{web, App, HttpServer, Responder};
use boringauth::actix_middleware::BoringAuthMiddleware;

async fn protected_route() -> impl Responder {
    "This is a protected route"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let auth_middleware = BoringAuthMiddleware::new("your-secret-key");
    
    HttpServer::new(move || {
        App::new()
            .wrap(auth_middleware.clone())
            .route("/protected", web::get().to(protected_route))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

完整示例demo

以下是一个完整的boringauth使用示例，包含用户注册、登录、角色管理和JWT令牌验证：

use boringauth::{
    AuthManager, PasswordHasher, UserCredentials, 
    Role, Permission, JwtValidator, JwtConfig
};
use std::collections::HashMap;

fn main() {
    // 初始化认证管理器
    let mut auth_manager = AuthManager::new();
    let hasher = PasswordHasher::default();
    
    // 1. 用户注册
    let credentials = UserCredentials {
        username: "admin_user".to_string(),
        password: "Admin@123".to_string(),
    };
    
    let hashed_password = hasher.hash(&credentials.password).unwrap();
    auth_manager.register_user(&credentials.username, &hashed_password).unwrap();
    
    // 2. 定义角色和权限
    let admin_role = Role::new("admin")
        .with_permission(Permission::new("create_user"))
        .with_permission(Permission::new("delete_user"))
        .with_permission(Permission::new("edit_content"));
    
    let editor_role = Role::new("editor")
        .with_permission(Permission::new("edit_content"));
    
    auth_manager.register_role(admin_role);
    auth_manager.register_role(editor_role);
    
    // 3. 为用户分配角色
    auth_manager.assign_role("admin_user", "admin").unwrap();
    
    // 4. 用户登录
    let login_result = auth_manager.authenticate("admin_user", "Admin@123");
    match login_result {
        Ok(token) => {
            println!("Login successful! Token: {}", token);
            
            // 5. JWT验证
            let jwt_config = JwtConfig::new("super-secret-key".to_string())
                .with_expiry(3600);
            
            let validator = JwtValidator::new(jwt_config);
            let claims = HashMap::from([
                ("username", "admin_user"),
                ("role", "admin")
            ]);
            
            // 生成新令牌
            let new_token = validator.generate_token(claims).unwrap();
            println!("Generated new token: {}", new_token);
            
            // 验证令牌
            match validator.validate_token(&new_token) {
                Ok(decoded_claims) => {
                    println!("Token is valid");
                    println!("User: {}", decoded_claims["username"]);
                    println!("Role: {}", decoded_claims["role"]);
                    
                    // 检查权限
                    if auth_manager.has_permission("admin_user", "delete_user") {
                        println!("User has delete_user permission");
                    }
                },
                Err(e) => println!("Token validation failed: {}", e),
            }
        },
        Err(e) => println!("Login failed: {}", e),
    }
}

最佳实践

1. 始终使用HTTPS传输认证令牌
2. 定期轮换JWT签名密钥
3. 为不同权限级别实现最小权限原则
4. 记录所有认证失败尝试
5. 考虑实现多因素认证(MFA)以增强安全性

boringauth通过提供简单而强大的API，帮助Rust开发者快速实现安全的认证和授权系统，同时保持代码的整洁和可维护性。