Autenticação Básica
Middleware que fornece suporte a Basic Auth.
Introdução à Autenticação Básica
Basic Auth é um mecanismo simples de autenticação HTTP que transmite nome de usuário e senha através do cabeçalho Authorization
nas requisições HTTP. O formato é Authorization: Basic <base64(username:password)>
. Embora simples, como as credenciais são apenas codificadas em Base64 e não criptografadas, geralmente é necessário usar com HTTPS para garantir segurança.
Comparação de implementações de Basic Auth em frameworks comuns
Framework | Linguagem | Implementação Basic Auth |
---|
Salvo | Rust | Através do middleware BasicAuth e implementação personalizada de BasicAuthValidator |
Express | JavaScript | Usando o pacote middleware express-basic-auth |
Spring Security | Java | Configuração via httpBasic() e implementação de UserDetailsService |
ASP.NET Core | C# | Usando .UseAuthentication() e AddAuthentication(AuthenticationSchemes.Basic) |
Gin | Go | Através de middleware personalizado ou usando o pacote gin-contrib/auth |
Cenários de uso
Basic Auth é adequado para os seguintes cenários:
- APIs e ferramentas internas: Ferramentas administrativas e APIs de uso interno da empresa
- Ambientes de desenvolvimento e teste: Implementação rápida de autenticação sem sistemas complexos de login
- Proteção simples de APIs: Quando não é necessário um sistema complexo de gerenciamento de usuários
- Combinação com outras medidas de segurança: Como parte de uma arquitetura de segurança em camadas
No Salvo, o middleware Basic Auth pode ser facilmente integrado às rotas, com lógica de validação personalizada através da implementação da trait BasicAuthValidator
, oferecendo grande flexibilidade.
Considerações importantes
- Sempre use com HTTPS para proteger a transmissão das credenciais
- Não é adequado para ambientes de produção com informações sensíveis
- Considere usar métodos de autenticação mais seguros como JWT, OAuth etc. para ambientes de produção
basic-auth/src/main.rs
use salvo::basic_auth::{BasicAuth, BasicAuthValidator};
use salvo::prelude::*;
// Custom validator implementing BasicAuthValidator trait
struct Validator;
impl BasicAuthValidator for Validator {
// Validate username and password combination
async fn validate(&self, username: &str, password: &str, _depot: &mut Depot) -> bool {
username == "root" && password == "pwd"
}
}
// Simple handler that returns "Hello" for authenticated requests
#[handler]
async fn hello() -> &'static str {
"Hello"
}
// Create router with basic authentication middleware
fn route() -> Router {
// Initialize basic authentication handler with our validator
let auth_handler = BasicAuth::new(Validator);
// Apply authentication middleware to the router
Router::with_hoop(auth_handler).goal(hello)
}
#[tokio::main]
async fn main() {
// Initialize logging
tracing_subscriber::fmt().init();
// Bind server to port 5800 and start serving
let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
Server::new(acceptor).serve(route()).await;
}
#[cfg(test)]
mod tests {
use salvo::prelude::*;
use salvo::test::{ResponseExt, TestClient};
#[tokio::test]
async fn test_basic_auth() {
// Create a service instance from our router for testing purposes
let service = Service::new(super::route());
// Test case 1: Verify successful authentication with valid credentials
let content = TestClient::get("http://0.0.0.0:5800/")
.basic_auth("root", Some("pwd")) // Use correct username/password
.send(&service) // Send the request to the service
.await
.take_string() // Extract response body as string
.await
.unwrap();
// Verify response contains expected "Hello" message
assert!(content.contains("Hello"));
// Test case 2: Verify authentication failure with invalid password
let content = TestClient::get("http://0.0.0.0:5800/")
.basic_auth("root", Some("pwd2")) // Use incorrect password
.send(&service) // Send the request to the service
.await
.take_string() // Extract response body as string
.await
.unwrap();
// Verify response contains "Unauthorized" error
assert!(content.contains("Unauthorized"));
}
}