Mécanismes d'autorisation dans les applications Web Rust

Pour assurer la sécurité des applications, nous utilisons des mécanismes tels que l'authentification et l'autorisation. Je pense que beaucoup d'entre vous connaissent ces concepts et dans cet article, nous nous concentrerons sur le concept d'autorisation et les modèles de contrôle d'accès associés.

Définitions des termes utilisés dans cet article

      Il est important de comprendre les différences entre l'autorisation et l'authentification:

– , ( , ).

– , .

– , .

– , , .

(Crate) – Rust.

Le processus d'autorisation comprend le concept d'une politique de contrôle d'accès , selon laquelle un ensemble d'actions autorisées d'un utilisateur spécifique ( sujet d'accès ) sur les ressources du système ( objet d'accès ) est déterminé .

Et aussi le modèle de contrôle d'accès - un schéma général pour délimiter l'accès via une politique utilisateur, que nous choisissons en fonction de divers facteurs et exigences du système.

Jetons un coup d'œil aux modèles de contrôle d'accès de base:

• DAC ( Discretionary Access-Control ) - contrôle d'accès sélectif (discrétionnaire)

  
  
  
  
  

- , (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

Cette bibliothèque n'a pas encore d'intégrations avec de nombreux frameworks Web dans son arsenal, mais j'ai l'intention d'introduire des abstractions et d'écrire des modules pour d'autres frameworks, d'apporter des améliorations (par exemple, la possibilité d'hériter des rôles et de prendre en charge les types personnalisés). Toutes les suggestions et contributions seront les bienvenues!