auth4free 0.1.0

A modern, secure authentication library for Rust applications with password validation, JWT tokens, and bcrypt hashing.
Documentation

Auth4Free

A modern, secure, and easy-to-use authentication library for Rust applications.

Build Status License: MIT Rust Version

🚀 Features

  • Password Validation - Robust password strength checking and validation
  • JWT Authentication - Secure token-based authentication
  • Password Hashing - Industry-standard bcrypt password hashing
  • User Management - Complete user lifecycle management
  • Session Management - Secure session handling (coming soon)
  • Rate Limiting - Protection against brute force attacks (planned)
  • Multi-Factor Authentication - Enhanced security (planned)

📦 Installation

Add this to your Cargo.toml:

[dependencies]

authlib = "0.1.0"

🔧 Quick Start

Password Validation

use authlib::password_validation::*;

let config = PasswordValidationConfig::default();
let password = "MySecureP@ssw0rd!";

match validate_password(password, &config) {
    Ok(()) => println!("Password is valid!"),
    Err(e) => println!("Password invalid: {}", e),
}

// Check password strength
let score = password_strength_score(password);
let category = password_strength_category(score);
println!("Password strength: {} ({}/100)", category, score);

User Authentication

use authlib::auth::authenticate_user;
use authlib::user::User;

async fn login_example() -> Result<String, String> {
    let user = User::new("john_doe".to_string(), "john@example.com".to_string());
    let token = authenticate_user(user).await?;
    Ok(token)
}

🛡️ Security Features

Password Validation Rules

  • Minimum length requirements
  • Uppercase/lowercase letter requirements
  • Number and special character requirements
  • Consecutive character limits
  • Common password detection

Password Strength Analysis

use authlib::password_validation::*;

let passwords = vec![
    "password",                    // Very Weak
    "Password123",                 // Weak  
    "MySecureP@ssw0rd!",          // Strong
    "correct horse battery staple" // Very Strong
];

for pwd in passwords {
    let score = password_strength_score(pwd);
    let category = password_strength_category(score);
    println!("{}: {} ({}/100)", pwd, category, score);
}

📚 Examples

Check out the examples directory for complete working examples:

Run examples with:

cargo run --example password_validation

🧪 Testing

Run all tests:

cargo test

📖 Documentation

API documentation is available at docs.rs.

🔮 Future Features

Coming Soon

  • Session Management
  • Refresh Token System
  • Account Lockout Mechanisms

Planned Features

  • OAuth2 Provider Integration (Google, GitHub, etc.)
  • Multi-Factor Authentication (TOTP, SMS, Email)
  • Rate Limiting and Brute Force Protection
  • Email Verification System
  • Role-Based Access Control (RBAC)
  • Audit Logging

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/AmazingFeature)
  3. Commit your changes (git commit -m 'Add some AmazingFeature')
  4. Push to the branch (git push origin feature/AmazingFeature)
  5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

  • Built with security best practices in mind
  • Inspired by industry standards for authentication systems
  • Development assisted by AI pair programming tools

Made with ❤️ for the Rust community