use crate::service::ShieldService;
use http::{Response, StatusCode};
use std::sync::Arc;
use tower_layer::Layer;
use towershield_core::{CompiledRuleSet, Rule, RuleSet};
#[derive(Debug, Clone)]
pub struct BlockedResponse {
status: StatusCode,
}
impl Default for BlockedResponse {
fn default() -> Self {
BlockedResponse {
status: StatusCode::NOT_FOUND,
}
}
}
impl BlockedResponse {
pub fn with_status(status: StatusCode) -> Self {
BlockedResponse { status }
}
pub fn status(&self) -> StatusCode {
self.status
}
pub fn build<B: Default>(&self) -> Response<B> {
let mut resp = Response::new(B::default());
*resp.status_mut() = self.status;
resp.headers_mut().insert(
http::header::CONTENT_LENGTH,
http::HeaderValue::from_static("0"),
);
resp
}
}
pub type OnBlock =
Arc<dyn Fn(&towershield_core::ShieldMatch, &http::Method, &str) + Send + Sync + 'static>;
pub struct ShieldBuilder {
rules: BuilderRules,
blocked_response: BlockedResponse,
on_block: Option<OnBlock>,
}
enum BuilderRules {
Builtin,
Custom(RuleSet),
}
impl Default for ShieldBuilder {
fn default() -> Self {
ShieldBuilder {
rules: BuilderRules::Builtin,
blocked_response: BlockedResponse::default(),
on_block: None,
}
}
}
impl ShieldBuilder {
pub fn with_ruleset(mut self, rs: RuleSet) -> Self {
self.rules = BuilderRules::Custom(rs);
self
}
pub fn add_rule(mut self, rule: Rule) -> Self {
self.rules = BuilderRules::Custom(match self.rules {
BuilderRules::Builtin => towershield_core::DEFAULT_RULES.get().push(rule),
BuilderRules::Custom(ruleset) => ruleset.push(rule),
});
self
}
pub fn with_blocked_response(mut self, r: BlockedResponse) -> Self {
self.blocked_response = r;
self
}
pub fn on_block(
mut self,
f: impl Fn(&towershield_core::ShieldMatch, &http::Method, &str) + Send + Sync + 'static,
) -> Self {
self.on_block = Some(Arc::new(f));
self
}
pub fn build(self) -> ShieldLayer {
self.try_build().expect("failed to compile shield rule set")
}
pub fn try_build(self) -> Result<ShieldLayer, towershield_core::ruleset::CompileError> {
let compiled = match self.rules {
BuilderRules::Builtin => towershield_core::DEFAULT_RULES.compiled(),
BuilderRules::Custom(ruleset) => ruleset.compile()?,
};
Ok(ShieldLayer {
inner: Arc::new(LayerInner {
compiled,
blocked_response: self.blocked_response,
on_block: self.on_block,
}),
})
}
}
pub(crate) struct LayerInner {
pub(crate) compiled: CompiledRuleSet,
pub(crate) blocked_response: BlockedResponse,
pub(crate) on_block: Option<OnBlock>,
}
impl std::fmt::Debug for LayerInner {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LayerInner")
.field("compiled", &self.compiled)
.field("blocked_response", &self.blocked_response)
.field("on_block", &self.on_block.as_ref().map(|_| "<fn>"))
.finish()
}
}
#[derive(Debug, Clone)]
pub struct ShieldLayer {
pub(crate) inner: Arc<LayerInner>,
}
impl Default for ShieldLayer {
fn default() -> Self {
ShieldBuilder::default().build()
}
}
impl ShieldLayer {
pub fn builder() -> ShieldBuilder {
ShieldBuilder::default()
}
}
impl<S> Layer<S> for ShieldLayer {
type Service = ShieldService<S>;
fn layer(&self, inner_service: S) -> Self::Service {
ShieldService::new(inner_service, Arc::clone(&self.inner))
}
}