20

我需要验证用户是否有权访问某些路线。我已经创建了 3 个“范围”（guest、auth-user、admin），现在我不知道如何检查用户是否可以访问这些路由。

我正在尝试实现 auth-middleware，这个中间件应该检查​​用户是否拥有正确的 cookie 或令牌。（我能够从请求标头中打印出一个 cookie），但我不知道如何导入、使用 actix_identity 以及访问此中间件中的 id 参数。

我相信我的问题不仅与 Actix 身份有关，而且我无法在中间件中传递参数。

    #[actix_rt::main]
    async fn main() -> std::io::Result<()> {

        let cookie_key = conf.server.key;
    
        // Register http routes
        let mut server = HttpServer::new(move || {
            App::new()
                // Enable logger
                .wrap(Logger::default())
                .wrap(IdentityService::new(
                    CookieIdentityPolicy::new(cookie_key.as_bytes())
                        .name("auth-cookie")
                        .path("/")
                        .secure(false),
                ))
                //limit the maximum amount of data that server will accept
                .data(web::JsonConfig::default().limit(4096))
                //normal routes
                .service(web::resource("/").route(web::get().to(status)))
                // .configure(routes)
                .service(
                    web::scope("/api")
                        // guest endpoints
                        .service(web::resource("/user_login").route(web::post().to(login)))
                        .service(web::resource("/user_logout").route(web::post().to(logout)))
                        // admin endpoints
                        .service(
                            web::scope("/admin")
                                // .wrap(AdminAuthMiddleware)
                                .service(
                                    web::resource("/create_admin").route(web::post().to(create_admin)),
                                )
                                .service(
                                    web::resource("/delete_admin/{username}/{_:/?}")
                                        .route(web::delete().to(delete_admin)),
                                ),
                        )
                        //user auth routes
                        .service(
                            web::scope("/auth")
                                // .wrap(UserAuthMiddleware)
                                .service(web::resource("/get_user").route(web::get().to(get_user))),
                        ),
                )
        });
    
        // Enables us to hot reload the server
        let mut listenfd = ListenFd::from_env();
        server = if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
            server.listen(l)?
        } else {
            server.bind(ip)?
        };
    
        server.run().await

我尝试过的资源：

  1. 为 Actix API 创建身份验证中间件 https://www.jamesbaum.co.uk/blether/creating-authentication-middleware-actix-rust-react/

  2. 中间件中的 Actix-web 令牌验证https://users.rust-lang.org/t/actix-web-token-validation-in-middleware/38205

  3. Actix 中间件示例https://github.com/actix/examples/tree/master/middleware

也许我认为完全错误并且 auth-middleware 不是解决我的问题的最佳解决方案。我希望你能帮我创建“受保护的路线”

4

5 回答 5

18

尝试提取器

尝试在 Actix 3 中实现这种模式时，我头疼了一阵子试图使用中间件，基本上是做一个守卫，然后弄清楚如何将数据从中间件传递到处理程序。这很痛苦，最终我意识到我是在反对 Actix 而不是与它合作。

最后我了解到获取信息给处理程序的方法是创建一个结构（AuthedUser也许？）并FromRequest在该结构上实现特征。

然后，每个在函数签名中请求的处理程序都AuthedUser将被验证门控，如果用户已登录，您将AuthedUser在该FromRequest::from_request方法中附加任何用户信息。

Actix 指的是这些实现FromRequest为提取器的结构。这有点神奇，可以在指南中引起更多关注。

于 2021-01-19T04:00:23.227 回答
8

以下不使用中间件（需要做更多的工作），但它解决了最低限度的问题，并且似乎是文档中建议的方法：

#[macro_use]
extern crate actix_web;
use actix::prelude::*;
use actix_identity::{CookieIdentityPolicy, Identity, IdentityService};
use actix_web::{
    dev::Payload, error::ErrorUnauthorized, web, App, Error, FromRequest, HttpRequest,
    HttpResponse, HttpServer, Responder,
};
use log::{info, warn};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, pin::Pin, sync::RwLock};

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
struct Sessions {
    map: HashMap<String, User>,
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
#[serde(rename_all = "camelCase")]
struct Login {
    id: String,
    username: String,
    scope: Scope,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
enum Scope {
    Guest,
    User,
    Admin,
}

impl Default for Scope {
    fn default() -> Self {
        Scope::Guest
    }
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
#[serde(rename_all = "camelCase")]
struct User {
    id: String,
    first_name: Option<String>,
    last_name: Option<String>,
    authorities: Scope,
}

impl FromRequest for User {
    type Config = ();
    type Error = Error;
    type Future = Pin<Box<dyn Future<Output = Result<User, Error>>>>;

    fn from_request(req: &HttpRequest, pl: &mut Payload) -> Self::Future {
        let fut = Identity::from_request(req, pl);
        let sessions: Option<&web::Data<RwLock<Sessions>>> = req.app_data();
        if sessions.is_none() {
            warn!("sessions is empty(none)!");
            return Box::pin(async { Err(ErrorUnauthorized("unauthorized")) });
        }
        let sessions = sessions.unwrap().clone();
        Box::pin(async move {
            if let Some(identity) = fut.await?.identity() {
                if let Some(user) = sessions
                    .read()
                    .unwrap()
                    .map
                    .get(&identity)
                    .map(|x| x.clone())
                {
                    return Ok(user);
                }
            };

            Err(ErrorUnauthorized("unauthorized"))
        })
    }
}

#[get("/admin")]
async fn admin(user: User) -> impl Responder {
    if user.authorities != Scope::Admin {
        return HttpResponse::Unauthorized().finish();
    }
    HttpResponse::Ok().body("You are an admin")
}

#[get("/account")]
async fn account(user: User) -> impl Responder {
    web::Json(user)
}

#[post("/login")]
async fn login(
    login: web::Json<Login>,
    sessions: web::Data<RwLock<Sessions>>,
    identity: Identity,
) -> impl Responder {
    let id = login.id.to_string();
    let scope = &login.scope;
    //let user = fetch_user(login).await // from db?
    identity.remember(id.clone());
    let user = User {
        id: id.clone(),
        last_name: Some(String::from("Doe")),
        first_name: Some(String::from("John")),
        authorities: scope.clone(),
    };
    sessions.write().unwrap().map.insert(id, user.clone());
    info!("login user: {:?}", user);
    HttpResponse::Ok().json(user)
}

#[post("/logout")]
async fn logout(sessions: web::Data<RwLock<Sessions>>, identity: Identity) -> impl Responder {
    if let Some(id) = identity.identity() {
        identity.forget();
        if let Some(user) = sessions.write().unwrap().map.remove(&id) {
            warn!("logout user: {:?}", user);
        }
    }
    HttpResponse::Unauthorized().finish()
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
    env_logger::init();

    let sessions = web::Data::new(RwLock::new(Sessions {
        map: HashMap::new(),
    }));

    HttpServer::new(move || {
        App::new()
            .app_data(sessions.clone())
            .wrap(IdentityService::new(
                CookieIdentityPolicy::new(&[0; 32])
                    .name("test")
                    .secure(false),
            ))
            .service(account)
            .service(login)
            .service(logout)
            .service(admin)
    })
    .bind("127.0.0.1:8088")?
    .run()
    .await
}

您可以在此处克隆并运行它：https ://github.com/geofmureithi/actix-acl-example

于 2020-07-29T16:28:16.397 回答
3

我认为actix-web grants crate 非常适合您。它允许您使用Guard或过程宏检查授权（参见github 上的示例）。它还与现有的授权中间件（如actix-web-httpauth）很好地集成。

为了清楚起见，举几个例子：

  • proc-macro方法
#[get("/secure")]
#[has_permissions("ROLE_ADMIN")]
async fn macro_secured() -> HttpResponse {
    HttpResponse::Ok().body("ADMIN_RESPONSE")
}
  • Guard方法
App::new()
    .wrap(GrantsMiddleware::with_extractor(extract))
    .service(web::resource("/admin")
            .to(|| async { HttpResponse::Ok().finish() })
            .guard(PermissionGuard::new("ROLE_ADMIN".to_string())))

你也可以看看actix-casbin-auth（casbin集成到actix的实现）

于 2021-02-01T19:47:43.197 回答
1

这实际上在最新的 actix-web 版本 3.0 中很难实现。我所做的是从actix-web 1.0版本中复制 CookieIdentityPolicy 中间件并根据我的喜好对其进行修改。然而，这不是即插即用代码。这里和这里是我的版本。通常我会避免使用 actix-web，让线程/actor 在后台生成并让它执行 HTTP 请求是一场噩梦。然后尝试与处理程序共享结果更是如此。

于 2020-08-11T18:08:24.673 回答
1

中间件对于它定义的所有泛型和内部类型看起来不是很友好，但它是一个简单的结构，可以包装下一个要调用的服务。下一个服务是什么，由您创建应用程序或定义路由时的链调用决定。您在中间件中使用通用 S ，它将在编译时进行单态化，因此您不必关心中间件将保护哪种具体类型。

以下中间件使用通过 .data() 传递给您的应用程序的简单配置来检查“令牌”标头是否包含相同的魔法值。它要么通过下一个服务，要么返回一个未授权的错误（期货）。

use crate::config::Config;

use actix_service::{Service, Transform};
use actix_web::{
    dev::{ServiceRequest, ServiceResponse},
    error::ErrorUnauthorized,
    web::Data,
    Error,
};
use futures::future::{err, ok, Either, Ready};
use std::task::{Context, Poll};

pub struct TokenAuth;

impl<S, B> Transform<S> for TokenAuth
where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = TokenAuthMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ok(TokenAuthMiddleware { service })
    }
}

pub struct TokenAuthMiddleware<S> {
    service: S,
}

impl<S, B> Service for TokenAuthMiddleware<S>
where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
{    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = Either<S::Future, Ready<Result<Self::Response, Self::Error>>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&mut self, req: ServiceRequest) -> Self::Future {
        if let Some(token) = req
            .headers()
            .get("token")
            .and_then(|token| token.to_str().ok())
        {
            if let Some(config) = req.app_data::<Data<Config>>() {
                if token == config.token {
                    return Either::Left(self.service.call(req));
                }
            }
        }
        Either::Right(err(ErrorUnauthorized("not authorized")))
    }
}

保护你的功能就这么简单

#[post("/upload", wrap="TokenAuth")]
async fn upload(mut payload: Multipart) -> Result<HttpResponse, Error> {
}

请注意，您需要 actix_service 1.x 才能编译。actix_service 2 删除请求内部类型以使其通用，我无法使用 wrap="" 语法

于 2021-04-30T16:11:29.327 回答