Struct SecurityMiddleware 

pub struct SecurityMiddleware { /* private fields */ }

Available on crate feature middleware-security and native only.

Security middleware for HTTP security headers and redirects

Implementations

impl SecurityMiddleware

pub fn new() -> SecurityMiddleware

Available on (crate features standard or middleware) and crate feature security only.

Create a new SecurityMiddleware with default configuration

Examples

use std::sync::Arc;
use reinhardt_middleware::SecurityMiddleware;
use reinhardt_http::{Handler, Middleware, Request, Response};
use hyper::{StatusCode, Method, Version, HeaderMap};
use bytes::Bytes;

struct TestHandler;

#[async_trait::async_trait]
impl Handler for TestHandler {
    async fn handle(&self, _request: Request) -> reinhardt_core::exception::Result<Response> {
        Ok(Response::new(StatusCode::OK))
    }
}

let middleware = SecurityMiddleware::new();
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/data")
    .version(Version::HTTP_11)
    .headers(HeaderMap::new())
    .secure(true)
    .body(Bytes::new())
    .build()
    .unwrap();

let response = middleware.process(request, handler).await.unwrap();
assert!(response.headers.contains_key("Strict-Transport-Security"));
assert_eq!(response.headers.get("X-Content-Type-Options").unwrap(), "nosniff");

pub fn with_config(config: SecurityConfig) -> SecurityMiddleware

Available on (crate features standard or middleware) and crate feature security only.

Create a new SecurityMiddleware with custom configuration

Examples

use std::sync::Arc;
use reinhardt_middleware::{SecurityMiddleware, SecurityConfig};
use reinhardt_http::{Handler, Middleware, Request, Response};
use hyper::{StatusCode, Method, Version, HeaderMap};
use bytes::Bytes;

struct TestHandler;

#[async_trait::async_trait]
impl Handler for TestHandler {
    async fn handle(&self, _request: Request) -> reinhardt_core::exception::Result<Response> {
        Ok(Response::new(StatusCode::OK))
    }
}

let mut config = SecurityConfig::default();
config.hsts_enabled = true;
config.hsts_seconds = 31536000;
config.hsts_include_subdomains = true;
config.hsts_preload = true;
config.ssl_redirect = false;
config.content_type_nosniff = true;
config.referrer_policy = Some("strict-origin-when-cross-origin".to_string());
config.cross_origin_opener_policy = Some("same-origin".to_string());
config.x_frame_options = Some("DENY".to_string());
config.secure_proxy_ssl_header = None;

let middleware = SecurityMiddleware::with_config(config);
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/secure")
    .version(Version::HTTP_11)
    .headers(HeaderMap::new())
    .secure(true)
    .body(Bytes::new())
    .build()
    .unwrap();

let response = middleware.process(request, handler).await.unwrap();
let hsts = response.headers.get("Strict-Transport-Security").unwrap().to_str().unwrap();
assert!(hsts.contains("max-age=31536000"));
assert!(hsts.contains("includeSubDomains"));
assert!(hsts.contains("preload"));
assert_eq!(response.headers.get("Referrer-Policy").unwrap(), "strict-origin-when-cross-origin");

pub fn from_settings(settings: &Settings) -> SecurityMiddleware

👎Deprecated since 0.2.0:

use SecurityMiddleware::from_security_settings() instead

Available on (crate features standard or middleware) and crate feature security only.

Create a new SecurityMiddleware from application Settings

Maps security-related fields from Settings to SecurityConfig.

Examples

use reinhardt_conf::Settings;
use reinhardt_middleware::SecurityMiddleware;
use std::path::PathBuf;

#[allow(deprecated)]
let mut settings = Settings::new(PathBuf::from("/app"), "secret".to_string());
settings.core.security.secure_ssl_redirect = true;
settings.core.security.secure_hsts_seconds = Some(31536000);

#[allow(deprecated)]
let middleware = SecurityMiddleware::from_settings(&settings);

pub fn from_security_settings(settings: &SecuritySettings) -> SecurityMiddleware

Available on (crate features standard or middleware) and crate feature security only.

Create a new SecurityMiddleware from a SecuritySettings fragment

Maps security-related fields from SecuritySettings to the internal configuration. Middleware-specific defaults (e.g., content_type_nosniff, referrer_policy) are preserved from SecurityConfig::default.

Examples

use reinhardt_conf::SecuritySettings;
use reinhardt_middleware::SecurityMiddleware;

let settings = SecuritySettings {
    secure_ssl_redirect: true,
    secure_hsts_seconds: Some(31536000),
    ..Default::default()
};

let middleware = SecurityMiddleware::from_security_settings(&settings);

Trait Implementations

impl Default for SecurityMiddleware

fn default() -> SecurityMiddleware

Returns the “default value” for a type.

impl Middleware for SecurityMiddleware

fn process<'life0, 'async_trait>( &'life0 self, request: Request, handler: Arc<dyn Handler>, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, SecurityMiddleware: 'async_trait,

Processes a request through this middleware.

fn should_continue(&self, _request: &Request) -> bool

Determines whether this middleware should be executed for the given request.