refactor: Refactor the CaptchaFinder and CaptchaStorage to work with token and answer as string
All checks were successful
Rust CI / Rust CI (push) Successful in 1m9s

Signed-off-by: Awiteb <a@4rs.nl>
This commit is contained in:
Awiteb 2024-08-09 20:14:39 +00:00
parent 28e9406032
commit 2bfa4de8aa
Signed by: awiteb
GPG key ID: 3F6B55640AA6682F
6 changed files with 149 additions and 205 deletions

View file

@ -28,3 +28,7 @@ tempfile = "3.9"
tokio = { version = "1.35", features = ["macros", "rt-multi-thread"] } tokio = { version = "1.35", features = ["macros", "rt-multi-thread"] }
base64 = "0.21" base64 = "0.21"
salvo = { version = ">= 0.65, < 0.69", default-features = false, features = ["server", "http1","http2", "affix"] } salvo = { version = ">= 0.65, < 0.69", default-features = false, features = ["server", "http1","http2", "affix"] }
[[example]]
name = "simple_login"
required-features = ["cacache-storage"]

View file

@ -3,15 +3,6 @@
// You can see a video of this example here: // You can see a video of this example here:
// //
// Run the example with `cargo run --example simple_login --features cacache-storage` // Run the example with `cargo run --example simple_login --features cacache-storage`
//
// Or set up a crate for it, with the following `Cargo.toml`:
// ```toml
// [dependencies]
// base64 = ">= 0.21"
// salvo = { version = ">= 0.65", features = ["affix"] }
// salvo-captcha = { version = ">= 0.1", features = ["cacache-storage"] }
// tokio = { version = ">= 1.35", features = ["macros", "rt-multi-thread", "time"] }
// ```
use std::{sync::Arc, time::Duration}; use std::{sync::Arc, time::Duration};
@ -19,9 +10,6 @@ use base64::{engine::GeneralPurpose, Engine};
use salvo::prelude::*; use salvo::prelude::*;
use salvo_captcha::*; use salvo_captcha::*;
// The type of the captcha
type MyCaptcha = Captcha<CacacheStorage, CaptchaFormFinder<String, String>>;
// To convert the image to base64, to show it in the browser // To convert the image to base64, to show it in the browser
const BASE_64_ENGINE: GeneralPurpose = GeneralPurpose::new( const BASE_64_ENGINE: GeneralPurpose = GeneralPurpose::new(
&base64::alphabet::STANDARD, &base64::alphabet::STANDARD,
@ -29,7 +17,7 @@ const BASE_64_ENGINE: GeneralPurpose = GeneralPurpose::new(
); );
#[handler] #[handler]
async fn index(_req: &mut Request, res: &mut Response, depot: &mut Depot) { async fn index(res: &mut Response, depot: &mut Depot) {
// Get the captcha from the depot // Get the captcha from the depot
let captcha_storage = depot.obtain::<Arc<CacacheStorage>>().unwrap(); let captcha_storage = depot.obtain::<Arc<CacacheStorage>>().unwrap();
@ -51,7 +39,7 @@ async fn index(_req: &mut Request, res: &mut Response, depot: &mut Depot) {
#[handler] #[handler]
async fn auth(req: &mut Request, res: &mut Response, depot: &mut Depot) { async fn auth(req: &mut Request, res: &mut Response, depot: &mut Depot) {
// Get the captcha state from the depot, where we can know if the captcha is passed // Get the captcha state from the depot, where we can know if the captcha is passed
let captcha_state = depot.get_captcha_state().unwrap(); let captcha_state = depot.get_captcha_state();
// Not important, just for demo // Not important, just for demo
let Some(username) = req.form::<String>("username").await else { let Some(username) = req.form::<String>("username").await else {
res.status_code(StatusCode::BAD_REQUEST); res.status_code(StatusCode::BAD_REQUEST);
@ -76,7 +64,7 @@ async fn auth(req: &mut Request, res: &mut Response, depot: &mut Depot) {
#[tokio::main] #[tokio::main]
async fn main() { async fn main() {
let captcha_middleware = MyCaptcha::new( let captcha_middleware = Captcha::new(
CacacheStorage::new("./captcha-cache"), CacacheStorage::new("./captcha-cache"),
CaptchaFormFinder::new(), CaptchaFormFinder::new(),
) )
@ -115,6 +103,7 @@ async fn main() {
); );
let acceptor = TcpListener::new(("127.0.0.1", 5800)).bind().await; let acceptor = TcpListener::new(("127.0.0.1", 5800)).bind().await;
println!("Starting server on http://127.0.0.1:5800");
Server::new(acceptor).serve(router).await; Server::new(acceptor).serve(router).await;
captcha_cleaner.await.ok(); captcha_cleaner.await.ok();
} }

View file

@ -1,3 +1,14 @@
// Copyright (c) 2024, Awiteb <a@4rs.nl>
// A captcha middleware for Salvo framework.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
use crate::{CaptchaDifficulty, CaptchaName, CaptchaStorage}; use crate::{CaptchaDifficulty, CaptchaName, CaptchaStorage};
/// Captcha generator, used to generate a new captcha image. This trait are implemented for all [`CaptchaStorage`]. /// Captcha generator, used to generate a new captcha image. This trait are implemented for all [`CaptchaStorage`].
@ -11,7 +22,7 @@ pub trait CaptchaGenerator: CaptchaStorage {
&self, &self,
name: CaptchaName, name: CaptchaName,
difficulty: CaptchaDifficulty, difficulty: CaptchaDifficulty,
) -> impl std::future::Future<Output = Result<Option<(Self::Token, Vec<u8>)>, Self::Error>> + Send ) -> impl std::future::Future<Output = Result<Option<(String, Vec<u8>)>, Self::Error>> + Send
{ {
async { async {
let Some((captcha_answer, captcha_image)) = let Some((captcha_answer, captcha_image)) =
@ -20,7 +31,7 @@ pub trait CaptchaGenerator: CaptchaStorage {
return Ok(None); return Ok(None);
}; };
let token = self.store_answer(captcha_answer.into()).await?; let token = self.store_answer(captcha_answer).await?;
Ok(Some((token, captcha_image))) Ok(Some((token, captcha_image)))
} }
} }

View file

@ -9,49 +9,37 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE. // THE SOFTWARE.
use std::marker::PhantomData;
use salvo_core::http::header::HeaderName; use salvo_core::http::header::HeaderName;
use salvo_core::http::Request; use salvo_core::http::Request;
/// Trait to find the captcha token and answer from the request. /// Trait to find the captcha token and answer from the request.
pub trait CaptchaFinder: Send + Sync { pub trait CaptchaFinder: Send + Sync {
/// The token type
type Token: TryFrom<String> + Sync + Send;
/// The answer type
type Answer: TryFrom<String> + Sync + Send;
/// The token error type
type TError: std::fmt::Debug + Send;
/// The answer error type
type AError: std::fmt::Debug + Send;
/// Find the captcha token from the request. /// Find the captcha token from the request.
/// ///
/// Return [`None`] if the request does not contain a captcha token. An error is returned if the token is invalid format. /// ### Returns
/// - None: If the token is not found
/// - Some(None): If the token is found but is invalid (e.g. not a valid string)
/// - Some(Some(token)): If the token is found
fn find_token( fn find_token(
&self, &self,
req: &mut Request, req: &mut Request,
) -> impl std::future::Future<Output = Result<Option<Self::Token>, Self::TError>> + std::marker::Send; ) -> impl std::future::Future<Output = Option<Option<String>>> + std::marker::Send;
/// Find the captcha answer from the request. /// Find the captcha answer from the request.
/// ///
/// Return [`None`] if the request does not contain a captcha answer. An error is returned if the answer is invalid format. /// ### Returns
/// - None: If the answer is not found
/// - Some(None): If the answer is found but is invalid (e.g. not a valid string)
/// - Some(Some(answer)): If the answer is found
fn find_answer( fn find_answer(
&self, &self,
req: &mut Request, req: &mut Request,
) -> impl std::future::Future<Output = Result<Option<Self::Answer>, Self::AError>> + std::marker::Send; ) -> impl std::future::Future<Output = Option<Option<String>>> + std::marker::Send;
} }
/// Find the captcha token and answer from the header /// Find the captcha token and answer from the header
#[derive(Debug)] #[derive(Debug)]
pub struct CaptchaHeaderFinder<T, A> pub struct CaptchaHeaderFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
phantom: PhantomData<(T, A)>,
/// The header name of the captcha token /// The header name of the captcha token
/// ///
/// Default: "x-captcha-token" /// Default: "x-captcha-token"
@ -65,13 +53,7 @@ where
/// Find the captcha token and answer from the form /// Find the captcha token and answer from the form
#[derive(Debug)] #[derive(Debug)]
pub struct CaptchaFormFinder<T, A> pub struct CaptchaFormFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
phantom: PhantomData<(T, A)>,
/// The form name of the captcha token /// The form name of the captcha token
/// ///
/// Default: "captcha_token" /// Default: "captcha_token"
@ -83,11 +65,7 @@ where
pub answer_name: String, pub answer_name: String,
} }
impl<T, A> CaptchaHeaderFinder<T, A> impl CaptchaHeaderFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
/// Create a new CaptchaHeaderFinder /// Create a new CaptchaHeaderFinder
pub fn new() -> Self { pub fn new() -> Self {
Self::default() Self::default()
@ -106,11 +84,7 @@ where
} }
} }
impl<T, A> CaptchaFormFinder<T, A> impl CaptchaFormFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
/// Create a new CaptchaFormFinder /// Create a new CaptchaFormFinder
pub fn new() -> Self { pub fn new() -> Self {
Self::default() Self::default()
@ -129,99 +103,57 @@ where
} }
} }
impl<T, A> Default for CaptchaHeaderFinder<T, A> impl Default for CaptchaHeaderFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
/// Create a default CaptchaHeaderFinder with: /// Create a default CaptchaHeaderFinder with:
/// - token_header: "x-captcha-token" /// - token_header: "x-captcha-token"
/// - answer_header: "x-captcha-answer" /// - answer_header: "x-captcha-answer"
fn default() -> Self { fn default() -> Self {
Self { Self {
phantom: PhantomData,
token_header: HeaderName::from_static("x-captcha-token"), token_header: HeaderName::from_static("x-captcha-token"),
answer_header: HeaderName::from_static("x-captcha-answer"), answer_header: HeaderName::from_static("x-captcha-answer"),
} }
} }
} }
impl<T, A> Default for CaptchaFormFinder<T, A> impl Default for CaptchaFormFinder {
where
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
{
/// Create a default CaptchaFormFinder with: /// Create a default CaptchaFormFinder with:
/// - token_name: "captcha_token" /// - token_name: "captcha_token"
/// - answer_name: "captcha_answer" /// - answer_name: "captcha_answer"
fn default() -> Self { fn default() -> Self {
Self { Self {
phantom: PhantomData,
token_name: "captcha_token".to_string(), token_name: "captcha_token".to_string(),
answer_name: "captcha_answer".to_string(), answer_name: "captcha_answer".to_string(),
} }
} }
} }
impl<T, A> CaptchaFinder for CaptchaHeaderFinder<T, A> impl CaptchaFinder for CaptchaHeaderFinder {
where async fn find_token(&self, req: &mut Request) -> Option<Option<String>> {
T: TryFrom<String> + Sync + Send,
A: TryFrom<String> + Sync + Send,
<T as TryFrom<String>>::Error: Send,
<T as TryFrom<String>>::Error: std::fmt::Debug,
<A as TryFrom<String>>::Error: Send,
<A as TryFrom<String>>::Error: std::fmt::Debug,
{
type Token = T;
type Answer = A;
type TError = <T as TryFrom<String>>::Error;
type AError = <A as TryFrom<String>>::Error;
async fn find_token(&self, req: &mut Request) -> Result<Option<Self::Token>, Self::TError> {
req.headers() req.headers()
.get(&self.token_header) .get(&self.token_header)
.and_then(|t| t.to_str().ok()) .map(|t| t.to_str().map(ToString::to_string).ok())
.map(|t| Self::Token::try_from(t.to_string()))
.transpose()
} }
async fn find_answer(&self, req: &mut Request) -> Result<Option<Self::Answer>, Self::AError> { async fn find_answer(&self, req: &mut Request) -> Option<Option<String>> {
req.headers() req.headers()
.get(&self.answer_header) .get(&self.answer_header)
.and_then(|a| a.to_str().ok()) .map(|a| a.to_str().map(ToString::to_string).ok())
.map(|a| Self::Answer::try_from(a.to_string()))
.transpose()
} }
} }
impl<T, A> CaptchaFinder for CaptchaFormFinder<T, A> impl CaptchaFinder for CaptchaFormFinder {
where async fn find_token(&self, req: &mut Request) -> Option<Option<String>> {
T: TryFrom<String> + Sync + Send, req.form_data()
A: TryFrom<String> + Sync + Send,
<T as TryFrom<String>>::Error: Send,
<T as TryFrom<String>>::Error: std::fmt::Debug,
<A as TryFrom<String>>::Error: Send,
<A as TryFrom<String>>::Error: std::fmt::Debug,
{
type Token = T;
type Answer = A;
type TError = <T as TryFrom<String>>::Error;
type AError = <A as TryFrom<String>>::Error;
async fn find_token(&self, req: &mut Request) -> Result<Option<Self::Token>, Self::TError> {
req.form::<String>(&self.token_name)
.await .await
.map(|t| Self::Token::try_from(t.to_string())) .map(|form| form.fields.get(&self.token_name).cloned())
.transpose() .ok()
} }
async fn find_answer(&self, req: &mut Request) -> Result<Option<Self::Answer>, Self::AError> { async fn find_answer(&self, req: &mut Request) -> Option<Option<String>> {
req.form::<String>(&self.answer_name) req.form_data()
.await .await
.map(|a| Self::Answer::try_from(a.to_string())) .map(|form| form.fields.get(&self.answer_name).cloned())
.transpose() .ok()
} }
} }
@ -234,77 +166,90 @@ mod tests {
#[tokio::test] #[tokio::test]
async fn test_captcha_header_finder() { async fn test_captcha_header_finder() {
let finder = CaptchaHeaderFinder::<String, String>::new(); let finder = CaptchaHeaderFinder::new();
let mut req = Request::default(); let mut req = Request::default();
let headers = req.headers_mut(); let headers = req.headers_mut();
let token = uuid::Uuid::new_v4();
headers.insert( headers.insert(
HeaderName::from_static("x-captcha-token"), HeaderName::from_static("x-captcha-token"),
HeaderValue::from_str(&token.to_string()).unwrap(), HeaderValue::from_str("token").unwrap(),
); );
headers.insert( headers.insert(
HeaderName::from_static("x-captcha-answer"), HeaderName::from_static("x-captcha-answer"),
HeaderValue::from_static("answer"), HeaderValue::from_static("answer"),
); );
assert_eq!( assert_eq!(
finder.find_token(&mut req).await, finder.find_token(&mut req).await,
Ok(Some(token.to_string())) Some(Some("token".to_owned()))
); );
assert!(matches!( assert_eq!(
finder.find_answer(&mut req).await, finder.find_answer(&mut req).await,
Ok(Some(a)) if a == *"answer" Some(Some("answer".to_owned()))
)); );
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_header_finder_customized() { async fn test_captcha_header_finder_customized() {
let finder = CaptchaHeaderFinder::<String, String>::new() let finder = CaptchaHeaderFinder::new()
.token_header(HeaderName::from_static("token")) .token_header(HeaderName::from_static("token"))
.answer_header(HeaderName::from_static("answer")); .answer_header(HeaderName::from_static("answer"));
let mut req = Request::default(); let mut req = Request::default();
let headers = req.headers_mut(); let headers = req.headers_mut();
let token = uuid::Uuid::new_v4();
headers.insert( headers.insert(
HeaderName::from_static("token"), HeaderName::from_static("token"),
HeaderValue::from_str(&token.to_string()).unwrap(), HeaderValue::from_str("token").unwrap(),
); );
headers.insert( headers.insert(
HeaderName::from_static("answer"), HeaderName::from_static("answer"),
HeaderValue::from_static("answer"), HeaderValue::from_static("answer"),
); );
assert_eq!( assert_eq!(
finder.find_token(&mut req).await, finder.find_token(&mut req).await,
Ok(Some(token.to_string())) Some(Some("token".to_owned()))
); );
assert!(matches!( assert_eq!(
finder.find_answer(&mut req).await, finder.find_answer(&mut req).await,
Ok(Some(a)) if a == *"answer" Some(Some("answer".to_owned()))
)); );
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_header_finder_none() { async fn test_captcha_header_finder_none() {
let finder = CaptchaHeaderFinder::<String, String>::new(); let finder = CaptchaHeaderFinder::new();
let mut req = Request::default(); let mut req = Request::default();
assert_eq!(finder.find_token(&mut req).await, Ok(None)); assert_eq!(finder.find_token(&mut req).await, None);
assert_eq!(finder.find_answer(&mut req).await, Ok(None)); assert_eq!(finder.find_answer(&mut req).await, None);
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_header_finder_customized_none() { async fn test_captcha_header_finder_customized_none() {
let finder = CaptchaHeaderFinder::<String, String>::new() let finder = CaptchaHeaderFinder::new()
.token_header(HeaderName::from_static("token")) .token_header(HeaderName::from_static("token"))
.answer_header(HeaderName::from_static("answer")); .answer_header(HeaderName::from_static("answer"));
let mut req = Request::default(); let mut req = Request::default();
let headers = req.headers_mut();
assert_eq!(finder.find_token(&mut req).await, Ok(None)); headers.insert(
assert_eq!(finder.find_answer(&mut req).await, Ok(None)); HeaderName::from_static("x-captcha-token"),
HeaderValue::from_str("token").unwrap(),
);
headers.insert(
HeaderName::from_static("x-captcha-answer"),
HeaderValue::from_static("answer"),
);
assert_eq!(finder.find_token(&mut req).await, None);
assert_eq!(finder.find_answer(&mut req).await, None);
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_form_finder() { async fn test_captcha_form_finder() {
let finder = CaptchaFormFinder::<String, String>::new(); let finder = CaptchaFormFinder::new();
let mut req = Request::default(); let mut req = Request::default();
*req.body_mut() = ReqBody::Once("captcha_token=token&captcha_answer=answer".into()); *req.body_mut() = ReqBody::Once("captcha_token=token&captcha_answer=answer".into());
let headers = req.headers_mut(); let headers = req.headers_mut();
@ -315,17 +260,17 @@ mod tests {
assert_eq!( assert_eq!(
finder.find_token(&mut req).await, finder.find_token(&mut req).await,
Ok(Some("token".to_string())) Some(Some("token".to_owned()))
); );
assert!(matches!( assert_eq!(
finder.find_answer(&mut req).await, finder.find_answer(&mut req).await,
Ok(Some(a)) if a == *"answer" Some(Some("answer".to_owned()))
)); );
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_form_finder_customized() { async fn test_captcha_form_finder_customized() {
let finder = CaptchaFormFinder::<String, String>::new() let finder = CaptchaFormFinder::new()
.token_name("token".to_string()) .token_name("token".to_string())
.answer_name("answer".to_string()); .answer_name("answer".to_string());
let mut req = Request::default(); let mut req = Request::default();
@ -338,17 +283,17 @@ mod tests {
assert_eq!( assert_eq!(
finder.find_token(&mut req).await, finder.find_token(&mut req).await,
Ok(Some("token".to_string())) Some(Some("token".to_owned()))
); );
assert!(matches!( assert_eq!(
finder.find_answer(&mut req).await, finder.find_answer(&mut req).await,
Ok(Some(a)) if a == *"answer" Some(Some("answer".to_owned()))
)); );
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_form_finder_none() { async fn test_captcha_form_finder_none() {
let finder = CaptchaFormFinder::<String, String>::new(); let finder = CaptchaFormFinder::new();
let mut req = Request::default(); let mut req = Request::default();
*req.body_mut() = ReqBody::Once("".into()); *req.body_mut() = ReqBody::Once("".into());
let headers = req.headers_mut(); let headers = req.headers_mut();
@ -357,13 +302,13 @@ mod tests {
HeaderValue::from_str(&ContentType::form_url_encoded().to_string()).unwrap(), HeaderValue::from_str(&ContentType::form_url_encoded().to_string()).unwrap(),
); );
assert_eq!(finder.find_token(&mut req).await, Ok(None)); assert_eq!(finder.find_token(&mut req).await, Some(None));
assert_eq!(finder.find_answer(&mut req).await, Ok(None)); assert_eq!(finder.find_answer(&mut req).await, Some(None));
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_form_finder_customized_none() { async fn test_captcha_form_finder_customized_none() {
let finder = CaptchaFormFinder::<String, String>::new() let finder = CaptchaFormFinder::new()
.token_name("token".to_string()) .token_name("token".to_string())
.answer_name("answer".to_string()); .answer_name("answer".to_string());
let mut req = Request::default(); let mut req = Request::default();
@ -374,13 +319,13 @@ mod tests {
HeaderValue::from_str(&ContentType::form_url_encoded().to_string()).unwrap(), HeaderValue::from_str(&ContentType::form_url_encoded().to_string()).unwrap(),
); );
assert_eq!(finder.find_token(&mut req).await, Ok(None)); assert_eq!(finder.find_token(&mut req).await, Some(None));
assert_eq!(finder.find_answer(&mut req).await, Ok(None)); assert_eq!(finder.find_answer(&mut req).await, Some(None));
} }
#[tokio::test] #[tokio::test]
async fn test_captcha_form_finder_invalid() { async fn test_captcha_form_finder_invalid() {
let finder = CaptchaFormFinder::<String, String>::new(); let finder = CaptchaFormFinder::new();
let mut req = Request::default(); let mut req = Request::default();
*req.body_mut() = ReqBody::Once("captcha_token=token&captcha_answer=answer".into()); *req.body_mut() = ReqBody::Once("captcha_token=token&captcha_answer=answer".into());
let headers = req.headers_mut(); let headers = req.headers_mut();
@ -389,7 +334,7 @@ mod tests {
HeaderValue::from_str(&ContentType::json().to_string()).unwrap(), HeaderValue::from_str(&ContentType::json().to_string()).unwrap(),
); );
assert_eq!(finder.find_token(&mut req).await, Ok(None)); assert_eq!(finder.find_token(&mut req).await, None);
assert_eq!(finder.find_answer(&mut req).await, Ok(None)); assert_eq!(finder.find_answer(&mut req).await, None);
} }
} }

View file

@ -36,7 +36,7 @@ pub const CAPTCHA_STATE_KEY: &str = "::salvo_captcha::captcha_state";
pub struct Captcha<S, F> pub struct Captcha<S, F>
where where
S: CaptchaStorage, S: CaptchaStorage,
F: CaptchaFinder<Token = S::Token, Answer = S::Answer>, F: CaptchaFinder,
{ {
/// The captcha finder, used to find the captcha token and answer from the request. /// The captcha finder, used to find the captcha token and answer from the request.
finder: F, finder: F,
@ -47,20 +47,20 @@ where
} }
/// The captcha states of the request /// The captcha states of the request
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
pub enum CaptchaState { pub enum CaptchaState {
/// The captcha check is skipped. This depends on the skipper.
#[default]
Skipped,
/// The captcha is checked and passed. If the captcha is passed, it will be cleared from the storage. /// The captcha is checked and passed. If the captcha is passed, it will be cleared from the storage.
Passed, Passed,
/// The captcha check is skipped. This depends on the skipper.
Skipped,
/// Can't find the captcha token in the request /// Can't find the captcha token in the request
TokenNotFound, TokenNotFound,
/// Can't find the captcha answer in the request /// Can't find the captcha answer in the request
AnswerNotFound, AnswerNotFound,
/// The captcha token is wrong, can't find the captcha in the storage. /// Can't find the captcha token in the storage or the token is wrong (not valid string)
/// Maybe the captcha token entered by the user is wrong, or the captcha is expired, because the storage has been cleared.
WrongToken, WrongToken,
/// The captcha answer is wrong. This will not clear the captcha from the storage. /// Can't find the captcha answer in the storage or the answer is wrong (not valid string)
WrongAnswer, WrongAnswer,
/// Storage error /// Storage error
StorageError, StorageError,
@ -69,13 +69,13 @@ pub enum CaptchaState {
impl<S, F> Captcha<S, F> impl<S, F> Captcha<S, F>
where where
S: CaptchaStorage, S: CaptchaStorage,
F: CaptchaFinder<Token = S::Token, Answer = S::Answer>, F: CaptchaFinder,
{ {
/// Create a new Captcha /// Create a new Captcha
pub fn new(storage: impl Into<S>, finder: impl Into<F>) -> Self { pub fn new(storage: S, finder: F) -> Self {
Self { Self {
finder: finder.into(), finder,
storage: storage.into(), storage,
skipper: Box::new(none_skipper), skipper: Box::new(none_skipper),
} }
} }
@ -94,19 +94,22 @@ where
/// The captcha extension of the depot. /// The captcha extension of the depot.
/// Used to get the captcha info from the depot. /// Used to get the captcha info from the depot.
#[easy_ext::ext(CaptchaDepotExt)] pub trait CaptchaDepotExt {
impl Depot {
/// Get the captcha state from the depot /// Get the captcha state from the depot
pub fn get_captcha_state(&self) -> Option<&CaptchaState> { fn get_captcha_state(&self) -> CaptchaState;
self.get(CAPTCHA_STATE_KEY).ok() }
impl CaptchaDepotExt for Depot {
fn get_captcha_state(&self) -> CaptchaState {
self.get(CAPTCHA_STATE_KEY).cloned().unwrap_or_default()
} }
} }
#[async_trait::async_trait] #[salvo_core::async_trait]
impl<S, F> Handler for Captcha<S, F> impl<S, F> Handler for Captcha<S, F>
where where
S: CaptchaStorage, S: CaptchaStorage,
F: CaptchaFinder<Token = S::Token, Answer = S::Answer> + 'static, F: CaptchaFinder + 'static, // why?
{ {
async fn handle( async fn handle(
&self, &self,
@ -122,28 +125,28 @@ where
} }
let token = match self.finder.find_token(req).await { let token = match self.finder.find_token(req).await {
Ok(Some(token)) => token, Some(Some(token)) => token,
Ok(None) => { Some(None) => {
log::info!("Captcha token is not found in request"); log::info!("Captcha token is not found in request");
depot.insert(CAPTCHA_STATE_KEY, CaptchaState::TokenNotFound); depot.insert(CAPTCHA_STATE_KEY, CaptchaState::TokenNotFound);
return; return;
} }
Err(err) => { None => {
log::error!("Failed to find captcha token from request: {err:?}"); log::error!("Invalid token found in request");
depot.insert(CAPTCHA_STATE_KEY, CaptchaState::WrongToken); depot.insert(CAPTCHA_STATE_KEY, CaptchaState::WrongToken);
return; return;
} }
}; };
let answer = match self.finder.find_answer(req).await { let answer = match self.finder.find_answer(req).await {
Ok(Some(answer)) => answer, Some(Some(answer)) => answer,
Ok(None) => { Some(None) => {
log::info!("Captcha answer is not found in request"); log::info!("Captcha answer is not found in request");
depot.insert(CAPTCHA_STATE_KEY, CaptchaState::AnswerNotFound); depot.insert(CAPTCHA_STATE_KEY, CaptchaState::AnswerNotFound);
return; return;
} }
Err(err) => { None => {
log::error!("Failed to find captcha answer from request: {err:?}"); log::error!("Invalid answer found in request");
depot.insert(CAPTCHA_STATE_KEY, CaptchaState::WrongAnswer); depot.insert(CAPTCHA_STATE_KEY, CaptchaState::WrongAnswer);
return; return;
} }

View file

@ -26,24 +26,20 @@ pub trait CaptchaStorage: Send + Sync + 'static
where where
Self: Clone + std::fmt::Debug, Self: Clone + std::fmt::Debug,
{ {
/// The token type
type Token: TryFrom<String> + std::fmt::Display + Send + Sync;
/// The answer type
type Answer: std::cmp::PartialEq + From<String> + Send + Sync;
/// The error type of the storage. /// The error type of the storage.
type Error: std::fmt::Display + std::fmt::Debug + Send; type Error: std::fmt::Display + std::fmt::Debug + Send;
/// Store the captcha token and answer. /// Store the captcha token and answer.
fn store_answer( fn store_answer(
&self, &self,
answer: Self::Answer, answer: String,
) -> impl std::future::Future<Output = Result<Self::Token, Self::Error>> + Send; ) -> impl std::future::Future<Output = Result<String, Self::Error>> + Send;
/// Returns the answer of the captcha token. This method will return None if the token is not exist. /// Returns the answer of the captcha token. This method will return None if the token is not exist.
fn get_answer( fn get_answer(
&self, &self,
token: &Self::Token, token: &str,
) -> impl std::future::Future<Output = Result<Option<Self::Answer>, Self::Error>> + Send; ) -> impl std::future::Future<Output = Result<Option<String>, Self::Error>> + Send;
/// Clear the expired captcha. /// Clear the expired captcha.
fn clear_expired( fn clear_expired(
@ -54,7 +50,7 @@ where
/// Clear the captcha by token. /// Clear the captcha by token.
fn clear_by_token( fn clear_by_token(
&self, &self,
token: &Self::Token, token: &str,
) -> impl std::future::Future<Output = Result<(), Self::Error>> + Send; ) -> impl std::future::Future<Output = Result<(), Self::Error>> + Send;
} }
@ -86,19 +82,17 @@ impl CacacheStorage {
#[cfg(feature = "cacache-storage")] #[cfg(feature = "cacache-storage")]
impl CaptchaStorage for CacacheStorage { impl CaptchaStorage for CacacheStorage {
type Error = cacache::Error; type Error = cacache::Error;
type Token = String;
type Answer = String;
async fn store_answer(&self, answer: Self::Answer) -> Result<Self::Token, Self::Error> { async fn store_answer(&self, answer: String) -> Result<String, Self::Error> {
let token = uuid::Uuid::new_v4(); let token = uuid::Uuid::new_v4();
log::info!("Storing captcha answer to cacache for token: {token}"); log::info!("Storing captcha answer to cacache for token: {token}");
cacache::write(&self.cache_dir, token.to_string(), answer.as_bytes()).await?; cacache::write(&self.cache_dir, token.to_string(), answer.as_bytes()).await?;
Ok(token.to_string()) Ok(token.to_string())
} }
async fn get_answer(&self, token: &Self::Token) -> Result<Option<Self::Answer>, Self::Error> { async fn get_answer(&self, token: &str) -> Result<Option<String>, Self::Error> {
log::info!("Getting captcha answer from cacache for token: {token}"); log::info!("Getting captcha answer from cacache for token: {token}");
match cacache::read(&self.cache_dir, token.to_string()).await { match cacache::read(&self.cache_dir, token).await {
Ok(answer) => { Ok(answer) => {
log::info!("Captcha answer is exist in cacache for token: {token}"); log::info!("Captcha answer is exist in cacache for token: {token}");
Ok(Some( Ok(Some(
@ -120,7 +114,7 @@ impl CaptchaStorage for CacacheStorage {
async fn clear_expired(&self, expired_after: Duration) -> Result<(), Self::Error> { async fn clear_expired(&self, expired_after: Duration) -> Result<(), Self::Error> {
let now = SystemTime::now() let now = SystemTime::now()
.duration_since(std::time::UNIX_EPOCH) .duration_since(std::time::UNIX_EPOCH)
.expect("SystemTime must be later than UNIX_EPOCH") .expect("SystemTime before UNIX EPOCH!")
.as_millis(); .as_millis();
let expired_after = expired_after.as_millis(); let expired_after = expired_after.as_millis();
@ -143,10 +137,10 @@ impl CaptchaStorage for CacacheStorage {
Ok(()) Ok(())
} }
async fn clear_by_token(&self, token: &Self::Token) -> Result<(), Self::Error> { async fn clear_by_token(&self, token: &str) -> Result<(), Self::Error> {
log::info!("Clearing captcha token from cacache: {token}"); log::info!("Clearing captcha token from cacache: {token}");
let remove_opts = cacache::RemoveOpts::new().remove_fully(true); let remove_opts = cacache::RemoveOpts::new().remove_fully(true);
remove_opts.remove(&self.cache_dir, token.to_string()).await remove_opts.remove(&self.cache_dir, token).await
} }
} }
@ -155,20 +149,18 @@ where
T: CaptchaStorage, T: CaptchaStorage,
{ {
type Error = T::Error; type Error = T::Error;
type Token = T::Token;
type Answer = T::Answer;
fn store_answer( fn store_answer(
&self, &self,
answer: Self::Answer, answer: String,
) -> impl std::future::Future<Output = Result<Self::Token, Self::Error>> + Send { ) -> impl std::future::Future<Output = Result<String, Self::Error>> + Send {
self.as_ref().store_answer(answer) self.as_ref().store_answer(answer)
} }
fn get_answer( fn get_answer(
&self, &self,
token: &Self::Token, token: &str,
) -> impl std::future::Future<Output = Result<Option<Self::Answer>, Self::Error>> + Send { ) -> impl std::future::Future<Output = Result<Option<String>, Self::Error>> + Send {
self.as_ref().get_answer(token) self.as_ref().get_answer(token)
} }
@ -181,7 +173,7 @@ where
fn clear_by_token( fn clear_by_token(
&self, &self,
token: &Self::Token, token: &str,
) -> impl std::future::Future<Output = Result<(), Self::Error>> + Send { ) -> impl std::future::Future<Output = Result<(), Self::Error>> + Send {
self.as_ref().clear_by_token(token) self.as_ref().clear_by_token(token)
} }
@ -281,7 +273,7 @@ mod tests {
.expect("failed to check if token is exist") .expect("failed to check if token is exist")
.is_some()); .is_some());
assert!(storage assert!(storage
.get_answer(&"token".to_owned()) .get_answer("token")
.await .await
.expect("failed to check if token is exist") .expect("failed to check if token is exist")
.is_none()); .is_none());
@ -308,7 +300,7 @@ mod tests {
Some("answer".to_owned()) Some("answer".to_owned())
); );
assert!(storage assert!(storage
.get_answer(&"token".to_owned()) .get_answer("token")
.await .await
.expect("failed to get captcha answer") .expect("failed to get captcha answer")
.is_none()); .is_none());