use crate::telemetry::{LiveSecurityEvent, SecurityStore};
use axum::{
body::{Body, HttpBody},
http::{
HeaderMap, HeaderValue, Method, Request, Response, StatusCode,
header::{self, HeaderName},
},
};
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tower::{Layer, Service};
mod masking;
pub(crate) use masking::SegmentRewriter;
const MAX_BUFFERED_RESPONSE_BYTES: u64 = 2 * 1024 * 1024;
fn textual_media_type(headers: &HeaderMap) -> Option<&str> {
let value = headers.get(header::CONTENT_TYPE)?.to_str().ok()?;
let media_type = crate::media_type::essence(value);
if media_type.eq_ignore_ascii_case("text/event-stream") {
return None;
}
(crate::media_type::is_text(media_type) || crate::media_type::is_json(media_type))
.then_some(media_type)
}
fn has_identity_encoding(headers: &HeaderMap) -> bool {
headers
.get(header::CONTENT_ENCODING)
.is_none_or(|value| value.as_bytes().eq_ignore_ascii_case(b"identity"))
}
fn is_safely_bufferable(headers: &HeaderMap, body: &Body) -> bool {
let hint = body.size_hint();
let Some(upper) = hint.upper() else {
return false;
};
if !is_fixed_body_size_within_limit(hint.lower(), upper) {
return false;
}
match headers.get(header::CONTENT_LENGTH) {
Some(value) => value
.to_str()
.ok()
.and_then(|value| value.parse::<u64>().ok())
.is_some_and(|declared| declared == upper),
None => true,
}
}
const fn is_fixed_body_size_within_limit(lower: u64, upper: u64) -> bool {
lower == upper && upper <= MAX_BUFFERED_RESPONSE_BYTES
}
fn remove_stale_representation_headers(headers: &mut HeaderMap, body_len: usize) {
headers.remove(header::ETAG);
headers.remove(header::CONTENT_RANGE);
headers.remove(header::ACCEPT_RANGES);
headers.remove(HeaderName::from_static("content-md5"));
headers.remove(HeaderName::from_static("digest"));
headers.remove(HeaderName::from_static("content-digest"));
headers.remove(header::CONTENT_LENGTH);
if let Ok(value) = HeaderValue::from_str(&body_len.to_string()) {
headers.insert(header::CONTENT_LENGTH, value);
}
}
fn body_collection_failure() -> Response<Body> {
let mut response = Response::new(Body::from("response inspection failed"));
*response.status_mut() = StatusCode::BAD_GATEWAY;
response.headers_mut().insert(
header::CONTENT_TYPE,
HeaderValue::from_static("text/plain; charset=utf-8"),
);
response
.headers_mut()
.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
response
}
pub fn mask_response_payload(input: &[u8]) -> (Vec<u8>, bool) {
if input.is_empty() {
return (Vec::new(), false);
}
let Ok(text) = std::str::from_utf8(input) else {
return (input.to_vec(), false);
};
match masking::mask_text(text) {
Some(sanitized) => {
let store = SecurityStore::global();
store.inc_dlp_masked();
store.push_local_event(LiveSecurityEvent::local(
"DLP_SECRET_LEAK_PREVENTED",
"Neutralized secret credentials/key from outgoing HTTP response",
"unknown",
));
(sanitized.into_bytes(), true)
}
None => (input.to_vec(), false),
}
}
#[derive(Clone, Default)]
pub struct DlpResponseLayer;
impl<S> Layer<S> for DlpResponseLayer {
type Service = DlpResponseService<S>;
fn layer(&self, inner: S) -> Self::Service {
DlpResponseService { inner }
}
}
#[derive(Clone)]
pub struct DlpResponseService<S> {
inner: S,
}
impl<S> Service<Request<Body>> for DlpResponseService<S>
where
S: Service<Request<Body>, Response = Response<Body>> + Clone + Send + 'static,
S::Future: Send + 'static,
{
type Response = Response<Body>;
type Error = S::Error;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, req: Request<Body>) -> Self::Future {
let clone = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, clone);
let request_method = req.method().clone();
Box::pin(async move {
let res = inner.call(req).await?;
if request_method == Method::HEAD
|| res.status().is_informational()
|| matches!(
res.status(),
StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED
)
|| textual_media_type(res.headers()).is_none()
|| !has_identity_encoding(res.headers())
|| !is_safely_bufferable(res.headers(), res.body())
{
return Ok(res);
}
let (mut parts, body) = res.into_parts();
let bytes = match axum::body::to_bytes(body, MAX_BUFFERED_RESPONSE_BYTES as usize).await
{
Ok(bytes) => bytes,
Err(_) => return Ok(body_collection_failure()),
};
let (sanitized_bytes, was_modified) = mask_response_payload(&bytes);
if was_modified {
remove_stale_representation_headers(&mut parts.headers, sanitized_bytes.len());
}
Ok(Response::from_parts(parts, Body::from(sanitized_bytes)))
})
}
}
pub type DlpLayer = DlpResponseLayer;
pub type DlpService<S> = DlpResponseService<S>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn textual_media_types_are_recognized_in_any_ascii_case() {
for (media_type, textual) in [
("application/vnd.api+JSON", true),
("Application/Problem+Json; charset=utf-8", true),
("APPLICATION/JSON", true),
("Text/HTML", true),
("Text/Event-Stream", false),
("application/octet-stream", false),
] {
let mut headers = HeaderMap::new();
headers.insert(header::CONTENT_TYPE, HeaderValue::from_static(media_type));
assert_eq!(
textual_media_type(&headers).is_some(),
textual,
"{media_type}"
);
}
}
#[test]
fn test_mask_private_key() {
let payload = b"Error: key was -----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEA...\n-----END RSA PRIVATE KEY----- in config";
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
let masked_str = String::from_utf8(masked).unwrap();
assert!(masked_str.contains("[DLP_BLOCKED_PRIVATE_KEY]"));
assert!(!masked_str.contains("BEGIN RSA PRIVATE KEY"));
}
#[test]
fn test_mask_database_url() {
let payload =
b"{\"db\": \"postgres://admin:super_secret_password_123@localhost:5432/app\"}";
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
let masked_str = String::from_utf8(masked).unwrap();
assert!(masked_str.contains("postgres://admin:*****@localhost:5432/app"));
assert!(!masked_str.contains("super_secret_password_123"));
}
#[test]
fn test_clean_payload_untouched() {
let payload = b"{\"message\": \"Hello Rullst!\", \"status\": 200}";
let (masked, was_modified) = mask_response_payload(payload);
assert!(!was_modified);
assert_eq!(masked, payload);
}
#[test]
fn invalid_utf8_and_incomplete_pem_are_not_corrupted() {
let binary = b"\xff\xfeAKIAIOSFODNN7EXAMPLE";
let (masked, was_modified) = mask_response_payload(binary);
assert!(!was_modified);
assert_eq!(masked, binary);
let incomplete = b"prefix -----BEGIN PRIVATE KEY----- unfinished payload";
let (masked, was_modified) = mask_response_payload(incomplete);
assert!(!was_modified);
assert_eq!(masked, incomplete);
}
#[test]
fn test_mask_aws_access_key() {
let payload = b"{\"aws_key\": \"AKIAIOSFODNN7EXAMPLE\"}";
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
let masked_str = String::from_utf8(masked).unwrap();
assert!(masked_str.contains("AKIA****************"));
assert!(!masked_str.contains("AKIAIOSFODNN7EXAMPLE"));
}
#[test]
fn test_mask_mysql_and_redis_urls() {
let payload = b"mysql://root:my_secret_sql_pass@127.0.0.1:3306/db and redis://default:redis_auth_token@cache:6379";
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
let masked_str = String::from_utf8(masked).unwrap();
assert!(masked_str.contains("mysql://root:*****@127.0.0.1:3306/db"));
assert!(masked_str.contains("redis://default:*****@cache:6379"));
}
#[test]
fn test_mask_multiple_keys_and_dsns() {
let payload = br#"{"keys": ["AKIA1111111111111111", "AKIA2222222222222222"], "dbs": ["postgres://u1:p1@h1:5432/d1", "postgres://u2:p2@h2:5432/d2"]}"#;
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
let masked_str = String::from_utf8(masked).unwrap();
assert!(!masked_str.contains("AKIA1111111111111111"));
assert!(!masked_str.contains("AKIA2222222222222222"));
assert!(!masked_str.contains(":p1@"));
assert!(!masked_str.contains(":p2@"));
assert!(masked_str.contains("postgres://u1:*****@h1:5432/d1"));
assert!(masked_str.contains("postgres://u2:*****@h2:5432/d2"));
}
#[test]
fn database_url_masking_preserves_unicode_boundaries_after_shortening() {
let payload = "redis://user:abcdefghijklmnopqrst@abcdefghijklmn\u{a0}z";
let (masked, was_modified) = mask_response_payload(payload.as_bytes());
assert!(was_modified);
assert_eq!(
String::from_utf8(masked).unwrap(),
"redis://user:*****@abcdefghijklmn\u{a0}z"
);
}
#[test]
fn already_masked_database_urls_remain_stable_during_other_redactions() {
let payload = b"AKIAIOSFODNN7EXAMPLE redis://user:*****@cache.internal:6379/session";
let (masked, was_modified) = mask_response_payload(payload);
assert!(was_modified);
assert_eq!(
String::from_utf8(masked).unwrap(),
"AKIA**************** redis://user:*****@cache.internal:6379/session"
);
}
#[tokio::test]
async fn test_dlp_layer_middleware() {
use axum::http::{Request, StatusCode, header};
use axum::response::IntoResponse;
use axum::routing::get;
use tower::ServiceExt;
async fn secret_handler() -> impl IntoResponse {
let mut response = (
StatusCode::OK,
"Config leaked: postgres://user:secret123@db:5432/main",
)
.into_response();
response
.headers_mut()
.insert(header::ETAG, HeaderValue::from_static("\"old-validator\""));
response
}
async fn binary_handler() -> Response<Body> {
let payload = b"\xffpostgres://user:secret123@db:5432/main".to_vec();
let mut response = Response::new(Body::from(payload));
response.headers_mut().insert(
header::CONTENT_TYPE,
HeaderValue::from_static("application/octet-stream"),
);
response
}
async fn event_stream_handler() -> Response<Body> {
let mut response = Response::new(Body::from(
"data: postgres://user:secret123@db:5432/main\n\n",
));
response.headers_mut().insert(
header::CONTENT_TYPE,
HeaderValue::from_static("text/event-stream"),
);
response
}
async fn oversized_handler() -> Response<Body> {
let mut payload = vec![b'a'; MAX_BUFFERED_RESPONSE_BYTES as usize + 1];
payload.extend_from_slice(b"postgres://user:secret123@db:5432/main");
let mut response = Response::new(Body::from(payload));
response.headers_mut().insert(
header::CONTENT_TYPE,
HeaderValue::from_static("text/plain; charset=utf-8"),
);
response
}
let app = axum::Router::new()
.route("/secret", get(secret_handler))
.route("/binary", get(binary_handler))
.route("/events", get(event_stream_handler))
.route("/oversized", get(oversized_handler))
.layer(DlpResponseLayer);
let req = Request::builder()
.uri("/secret")
.body(Body::empty())
.unwrap();
let resp = app.clone().oneshot(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert!(resp.headers().get(header::ETAG).is_none());
let declared_length = resp
.headers()
.get(header::CONTENT_LENGTH)
.unwrap()
.to_str()
.unwrap()
.parse::<usize>()
.unwrap();
let body = axum::body::to_bytes(resp.into_body(), 10000).await.unwrap();
assert_eq!(declared_length, body.len());
let body_str = String::from_utf8(body.to_vec()).unwrap();
assert!(body_str.contains("postgres://user:*****@db:5432/main"));
assert!(!body_str.contains("secret123"));
for (path, limit) in [
("/binary", 10_000usize),
("/events", 10_000usize),
("/oversized", MAX_BUFFERED_RESPONSE_BYTES as usize + 10_000),
] {
let response = app
.clone()
.oneshot(Request::builder().uri(path).body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let bytes = axum::body::to_bytes(response.into_body(), limit)
.await
.unwrap();
assert!(
bytes
.windows(b"secret123".len())
.any(|window| window == b"secret123"),
"{path} must bypass DLP without truncation"
);
}
}
}
#[cfg(kani)]
#[cfg_attr(mutants, mutants::skip)]
mod kani_proofs {
use super::*;
#[kani::proof]
fn proof_buffer_size_gate_boundaries() {
let lower: u64 = kani::any();
let upper: u64 = kani::any();
let accepted = is_fixed_body_size_within_limit(lower, upper);
assert_eq!(
accepted,
lower == upper && upper <= MAX_BUFFERED_RESPONSE_BYTES
);
if accepted {
assert_eq!(lower, upper);
assert!(upper <= MAX_BUFFERED_RESPONSE_BYTES);
}
}
}