actix-modsecurity 0.1.2

ModSecurity middleware service and library for Actix Web
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::future::{Ready, ready};
use std::rc::Rc;

use actix_web::{
    Error,
    body::BoxBody,
    dev::{Service, ServiceRequest, ServiceResponse, Transform},
};

use crate::ModSecurityService;
use crate::modsecurity::ModSecurity;
use crate::service::ModSecurityInner;

/// ModSecurity middleware service
///
/// `Middleware` must be registered with `App::wrap()` method.
///
/// # Examples
///
/// ```
/// use actix_web::App;
/// use actix_modsecurity::{Middleware, ModSecurity};
///
/// let mut security = ModSecurity::new();
/// security.add_rules(r#"
///  SecRuleEngine On
///  SecRule REQUEST_URI "@rx admin" "id:1,phase:1,deny,status:401"
/// "#).expect("Failed to add rules");
///
/// let app = App::new().wrap(Middleware::new(security));
/// ```
pub struct Middleware(Rc<ModSecurity>);

impl Middleware {
    /// Creates a new `ModSecurity` middleware instance
    #[inline]
    pub fn new(modsecurity: ModSecurity) -> Self {
        Self(Rc::new(modsecurity))
    }
}

impl<S> Transform<S, ServiceRequest> for Middleware
where
    S: Service<ServiceRequest, Response = ServiceResponse<BoxBody>, Error = Error> + 'static,
    S::Future: 'static,
{
    type Response = ServiceResponse<BoxBody>;
    type Error = Error;
    type InitError = ();
    type Transform = ModSecurityService<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(ModSecurityService(Rc::new(ModSecurityInner {
            service: Rc::new(service),
            modsecurity: Rc::clone(&self.0),
        }))))
    }
}