我需要验证用户是否具有某些路由的权限。我已经做了 3 个"范围"(访客、身份验证用户、管理员(，现在我不知道如何检查用户是否可以访问这些路由。

我正在尝试实现身份验证中间件，这个中间件应该检查用户是否具有正确的 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

我尝试过的资源：

为 Actix API 创建身份验证中间件 https://www.jamesbaum.co.uk/blether/creating-authentication-middleware-actix-rust-react/
中间件 https://users.rust-lang.org/t/actix-web-token-validation-in-middleware/38205 中的 Actix-Web 令牌验证
https://github.com/actix/examples/tree/master/middleware Actix 中间件示例

也许我认为完全错误，身份验证中间件不是解决我问题的最佳解决方案。我希望你能帮我创建"受保护的路线">

尝试提取器

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

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

然后，每个要求在函数签名中AuthedUser的处理程序都将被授权门控，如果用户已登录，则将具有您在FromRequest::from_request方法中附加到AuthedUser的任何用户信息。

Actix 将这些实现FromRequest的结构称为提取器。这是一点魔力，可以在指南中使用更多注意力。

以下不使用中间件(需要更多的工作(，但它解决了熊最小值的问题，似乎是文档中建议的方法：

#[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

我认为actix-web赠款箱非常适合您。它允许您使用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(集成到actix中的casbin实现(

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

以下中间件使用传递给应用的简单配置(.data((来检查"token"标头是否包含相同的魔术值。它要么通过下一个服务，要么返回未经授权的错误(期货(。

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=" 语法一起使用

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

如何在 actix-web 中创建受保护的路由

尝试提取器

为清楚起见，有几个示例：

相关内容

最新更新

热门标签：