Mecanismos de autorização em aplicativos da web Rust

Para garantir a segurança do aplicativo, usamos mecanismos como autenticação e autorização. Acho que muitos de vocês estão familiarizados com esses conceitos e, neste artigo, vamos nos concentrar no conceito de autorização e nos modelos de controle de acesso relacionados.

Definições dos termos usados ​​neste artigo

      É importante entender as diferenças entre autorização e autenticação:

– , ( , ).

– , .

– , .

– , , .

(Crate) – Rust.

O processo de autorização inclui o conceito de uma política de controle de acesso , de acordo com a qual é determinado um conjunto de ações permissíveis de um determinado usuário ( sujeito de acesso ) sobre os recursos do sistema ( objeto de acesso ).

E também o modelo de controle de acesso - um esquema geral para delimitar o acesso por meio de uma política de usuário, que escolhemos dependendo de vários fatores e requisitos do sistema.

Vamos dar uma olhada nos modelos básicos de controle de acesso:

• DAC ( controle de acesso discricionário ) - controle de acesso seletivo (discricionário)

  
  
  
  
  

- , (ACL).



       , .

, .

• MAC (Mandatory access-control) –

  
  
  
  
  

(, ), .



( ), . .



, MAC , ( , ).

• RBAC (Role-Based access-control) –

  
  
  
  
  

, - . DAC, .

, .



, RBAC PBAC (Permission-Based access-control) , (: READ_DOCUMENT



, WRITE_DOCUMENT



, DELETE_DOCUMENT



) , – .

• ABAC (Attribute-Based access-control) –

  
  
  
  
  

, , .  

, , , , .., .

ABAC , ( ) ( ).

OWASP (Open Web Application Security Project) IBM.

, , .

- Rust?

, - (, actix-web, Rocket tide), Middleware, FromRequest Guard (Filter warp).

, . , .

, . , , .

casbin-rs

Casbin – production-ready , , ( ACL, RBAC, ABAC) .

casbin - PERM (Policy, Effect, Request, Matchers) , , .

# Request definition
[request_definition]
r = sub, obj, act

# Policy definition
[policy_definition]
p = sub, obj, act

# Policy effect
[policy_effect]
e = some(where (p.eft == allow))

# Matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, -

( ), PERM .

p, alice, data1, read
p, bob, data2, write
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .

use casbin::prelude::*;

#[tokio::main]
async fn main() -> () {
    let mut e = Enforcer::new("examples/acl_model.conf", "examples/acl_policy.csv").await?;
    e.enable_log(true);

    let sub = "alice"; // the user that wants to access a resource.
    let obj = "data1"; // the resource that is going to be accessed.
    let act = "read"; // the operation that the user performs on the resource.

    if let Ok(authorized) = e.enforce((sub, obj, act)) {
        if authorized {
            // permit alice to read data1
        } else {
            // deny the request
        }
    } else {
        // error occurs
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

. , !

, , , , , , , .

, backend Rust. PBAC -, ACL/RBAC.

: actix-web-grants.

actix-web-grants

Middleware



.

, , , : (ACL), (RBAC/PBAC).

       , :

// Sample application with grant protection based on extracting by your custom function
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        let auth = GrantsMiddleware::with_extractor(extract);
        App::new()
            .wrap(auth)
            .service(index)
    })
    .bind("localhost:8081")?
    .run()
    .await
}

async fn extract(_req: &ServiceRequest) -> Result<Vec<String>, Error> {
    // Here is a place for your code to get user permissions/grants/permissions from a request
    // For example from a token or database
    
    // Stub example
    Ok(vec![ROLE_ADMIN.to_string()])
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

: JWT-, , .



:

use actix_web_grants::proc_macro::{has_roles};

#[get("/secure")]
#[has_roles("ROLE_ADMIN")]
async fn macro_secured() -> HttpResponse {
    HttpResponse::Ok().body("ADMIN_RESPONSE")
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

actix-web-grants, .

, ( wrk) .

RBAC - : , . . GitHub: actix-web-authz-benchmark ( ).

:

rustc: v1.52.0 (stable); CPU: 2,6 GHz 6-Core Intel Core i7; RAM: 16 GB

, , actix-web-grants (endpoints), casbin-rs.

Post Scriptum

Esta biblioteca ainda não tem integrações com muitos frameworks web em seu arsenal, mas tenho planos de introduzir algumas abstrações e escrever módulos para outros frameworks, fazer algumas melhorias (por exemplo, a capacidade de herdar funções e oferecer suporte a tipos personalizados). Quaisquer sugestões e contribuições serão bem-vindas!