use crate::error::{ErrorData, Result};
use crate::interceptor::{apply_response_hook, ResponseHook};
use alien_error::{AlienError, Context, IntoAlienError};
use async_trait::async_trait;
use backon::{ExponentialBuilder, Retryable};
use serde::de::DeserializeOwned;
use std::time::Duration;
fn extract_request_body_string(request: &reqwest::Request) -> Option<String> {
request
.body()
.and_then(|body| body.as_bytes())
.map(|bytes| String::from_utf8_lossy(bytes).into_owned())
}
const HTTP_REQUEST_TEXT_CONTEXT_KEY: &str = "http_request_text";
pub fn redact_request_body<T>(result: Result<T>) -> Result<T> {
result.map_err(|mut e| {
if let Some(ErrorData::HttpResponseError {
http_request_text, ..
}) = e.error.as_mut()
{
*http_request_text = None;
}
scrub_request_body(e.context.as_mut());
let mut layer = e.source.as_deref_mut();
while let Some(err) = layer {
scrub_request_body(err.context.as_mut());
layer = err.source.as_deref_mut();
}
e
})
}
fn scrub_request_body(context: Option<&mut serde_json::Value>) {
if let Some(serde_json::Value::Object(map)) = context {
map.remove(HTTP_REQUEST_TEXT_CONTEXT_KEY);
}
}
const HTTP_RESPONSE_TEXT_CONTEXT_KEY: &str = "http_response_text";
const HTTP_STATUS_CONTEXT_KEY: &str = "http_status";
pub fn redact_response_body<T>(result: Result<T>) -> Result<T> {
result.map_err(|mut e| {
let mut succeeded = false;
if let Some(ErrorData::HttpResponseError {
message,
http_status,
http_response_text,
..
}) = e.error.as_mut()
{
if (200..300).contains(http_status) {
succeeded = true;
*http_response_text = None;
*message = withhold_parse_detail(message);
}
}
succeeded |= context_has_success_status(e.context.as_ref());
if succeeded {
e.message = withhold_parse_detail(&e.message);
}
scrub_success_response_body(e.context.as_mut());
let mut layer = e.source.as_deref_mut();
while let Some(err) = layer {
let layer_succeeded = succeeded || context_has_success_status(err.context.as_ref());
if layer_succeeded {
err.message = withhold_parse_detail(&err.message);
}
scrub_success_response_body(err.context.as_mut());
layer = err.source.as_deref_mut();
}
e
})
}
fn context_has_success_status(context: Option<&serde_json::Value>) -> bool {
context
.and_then(|context| context.get(HTTP_STATUS_CONTEXT_KEY))
.and_then(serde_json::Value::as_u64)
.is_some_and(|status| (200..300).contains(&status))
}
fn withhold_parse_detail(message: &str) -> String {
for prefix in [
"Invalid JSON response at field '",
"Invalid XML response at field '",
] {
if let Some(rest) = message.strip_prefix(prefix) {
let path = rest.split_once("': ").map_or("", |(path, _)| path);
return format!(
"{}{}': the response could not be parsed (details withheld because it can hold a secret)",
prefix, path
);
}
}
message.to_string()
}
fn scrub_success_response_body(context: Option<&mut serde_json::Value>) {
if let Some(serde_json::Value::Object(map)) = context {
if context_has_success_status(Some(&serde_json::Value::Object(map.clone()))) {
map.remove(HTTP_RESPONSE_TEXT_CONTEXT_KEY);
if let Some(serde_json::Value::String(message)) = map.get_mut("message") {
*message = withhold_parse_detail(message);
}
}
}
}
pub fn redact_secret_bodies<T>(result: Result<T>) -> Result<T> {
redact_response_body(redact_request_body(result))
}
fn build_and_extract_body(
builder: reqwest::RequestBuilder,
) -> Result<(reqwest::Client, reqwest::Request, Option<String>)> {
let (client, req_result) = builder.build_split();
let request = req_result
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Failed to build request".to_string(),
})?;
let body_string = extract_request_body_string(&request);
Ok((client, request, body_string))
}
pub async fn handle_json_response<T: DeserializeOwned>(
response: reqwest::Response,
request_body: Option<String>,
) -> Result<T> {
let status = response.status();
let url = response.url().to_string();
let response_text =
response
.text()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Failed to read response body".to_string(),
})?;
if !status.is_success() {
return Err(AlienError::new(ErrorData::HttpResponseError {
message: format!(
"Request failed with HTTP {}: {}",
status.as_u16(),
status.canonical_reason().unwrap_or("Unknown error")
),
url,
http_status: status.as_u16(),
http_request_text: request_body,
http_response_text: Some(response_text),
}));
}
let jd = &mut serde_json::Deserializer::from_str(&response_text);
let parsed_response: T = serde_path_to_error::deserialize(jd).map_err(|err| {
AlienError::new(ErrorData::HttpResponseError {
message: format!(
"Invalid JSON response at field '{}': {}",
err.path(),
err.inner()
),
url,
http_status: status.as_u16(),
http_request_text: request_body,
http_response_text: Some(response_text),
})
})?;
Ok(parsed_response)
}
pub async fn handle_xml_response<T: DeserializeOwned>(
response: reqwest::Response,
request_body: Option<String>,
) -> Result<T> {
let status = response.status();
let url = response.url().to_string();
let response_text =
response
.text()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Failed to read response body".to_string(),
})?;
if !status.is_success() {
return Err(AlienError::new(ErrorData::HttpResponseError {
message: format!(
"Request failed with HTTP {}: {}",
status.as_u16(),
status.canonical_reason().unwrap_or("Unknown error")
),
url,
http_status: status.as_u16(),
http_request_text: request_body,
http_response_text: Some(response_text),
}));
}
let mut xml_deserializer = quick_xml::de::Deserializer::from_str(&response_text);
let parsed_response: T =
serde_path_to_error::deserialize(&mut xml_deserializer).map_err(|err| {
AlienError::new(ErrorData::HttpResponseError {
message: format!(
"Invalid XML response at field '{}': {}",
err.path(),
err.inner()
),
url,
http_status: status.as_u16(),
http_request_text: request_body,
http_response_text: Some(response_text),
})
})?;
Ok(parsed_response)
}
pub async fn handle_no_response(
response: reqwest::Response,
request_body: Option<String>,
) -> Result<()> {
let status = response.status();
let url = response.url().to_string();
if !status.is_success() {
let response_text =
response
.text()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Failed to read error response body".to_string(),
})?;
return Err(AlienError::new(ErrorData::HttpResponseError {
message: format!(
"Request failed with HTTP {}: {}",
status.as_u16(),
status.canonical_reason().unwrap_or("Unknown error")
),
url,
http_status: status.as_u16(),
http_request_text: request_body,
http_response_text: Some(response_text),
}));
}
#[cfg(not(target_arch = "wasm32"))]
{
let mut response = response;
while response
.chunk()
.await
.into_alien_error()
.context(ErrorData::HttpResponseBodyReadFailed {
http_status: status.as_u16(),
})?
.is_some()
{}
}
#[cfg(target_arch = "wasm32")]
response
.bytes()
.await
.into_alien_error()
.context(ErrorData::HttpResponseBodyReadFailed {
http_status: status.as_u16(),
})?;
Ok(())
}
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
pub trait RequestBuilderExt {
fn with_retry(self) -> RetriableRequestBuilder;
async fn send_json<T: DeserializeOwned + 'static>(self) -> Result<T>;
async fn send_xml<T: DeserializeOwned + 'static>(self) -> Result<T>;
async fn send_no_response(self) -> Result<()>;
async fn send_raw(self) -> Result<reqwest::Response>;
}
pub fn default_retry_backoff() -> ExponentialBuilder {
let backoff = ExponentialBuilder::default()
.with_max_times(3)
.with_max_delay(Duration::from_secs(20))
.with_jitter();
if cfg!(feature = "no-retry-delay") {
backoff.with_min_delay(Duration::ZERO)
} else {
backoff
}
}
pub struct RetriableRequestBuilder {
inner: reqwest::RequestBuilder,
backoff: ExponentialBuilder,
retry_if: fn(&AlienError<ErrorData>) -> bool,
response_hook: Option<ResponseHook>,
}
impl RetriableRequestBuilder {
pub fn backoff(mut self, backoff: ExponentialBuilder) -> Self {
self.backoff = backoff;
self
}
pub fn retry_only_when(mut self, retry_if: fn(&AlienError<ErrorData>) -> bool) -> Self {
self.retry_if = retry_if;
self
}
fn is_retryable_error(e: &AlienError<ErrorData>) -> bool {
e.retryable
}
pub async fn send_json<T: DeserializeOwned + Send + 'static>(self) -> Result<T> {
let backoff = self.backoff;
let retry_if = self.retry_if;
let builder = self.inner;
let response_hook = self.response_hook;
let retryable = move || {
let attempt_builder = builder.try_clone();
let response_hook = response_hook.clone();
async move {
let attempt_builder = attempt_builder.ok_or_else(|| {
AlienError::new(ErrorData::GenericError {
message: "Request retry preparation failed".into(),
})
})?;
let (client, request, body_string) = build_and_extract_body(attempt_builder)?;
let new_builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_json_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_json_response(resp, body_string).await
}
}
};
retryable.retry(backoff).when(retry_if).await
}
pub async fn send_xml<T: DeserializeOwned + Send + 'static>(self) -> Result<T> {
let backoff = self.backoff;
let retry_if = self.retry_if;
let builder = self.inner;
let response_hook = self.response_hook;
let retryable = move || {
let attempt_builder = builder.try_clone();
let response_hook = response_hook.clone();
async move {
let attempt_builder = attempt_builder.ok_or_else(|| {
AlienError::new(ErrorData::GenericError {
message: "Request retry preparation failed".into(),
})
})?;
let (client, request, body_string) = build_and_extract_body(attempt_builder)?;
let new_builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_xml_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_xml_response(resp, body_string).await
}
}
};
retryable.retry(backoff).when(retry_if).await
}
pub async fn send_no_response(self) -> Result<()> {
let backoff = self.backoff;
let retry_if = self.retry_if;
let builder = self.inner;
let response_hook = self.response_hook;
let retryable = move || {
let attempt_builder = builder.try_clone();
let response_hook = response_hook.clone();
async move {
let attempt_builder = attempt_builder.ok_or_else(|| {
AlienError::new(ErrorData::GenericError {
message: "Request retry preparation failed".into(),
})
})?;
let (client, request, body_string) = build_and_extract_body(attempt_builder)?;
let new_builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_no_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
let resp = apply_response_hook(response_hook.as_ref(), resp).await?;
handle_no_response(resp, body_string).await
}
}
};
retryable.retry(backoff).when(retry_if).await
}
pub async fn send_raw(self) -> Result<reqwest::Response> {
let backoff = self.backoff;
let retry_if = self.retry_if;
let builder = self.inner;
let response_hook = self.response_hook;
let retryable = move || {
let attempt_builder = builder.try_clone();
let response_hook = response_hook.clone();
async move {
let attempt_builder = attempt_builder.ok_or_else(|| {
AlienError::new(ErrorData::GenericError {
message: "Request retry preparation failed".into(),
})
})?;
let (client, request, _body_string) = build_and_extract_body(attempt_builder)?;
let new_builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
apply_response_hook(response_hook.as_ref(), resp).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp = new_builder.send().await.into_alien_error().context(
ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
},
)?;
apply_response_hook(response_hook.as_ref(), resp).await
}
}
};
retryable.retry(backoff).when(retry_if).await
}
}
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl RequestBuilderExt for reqwest::RequestBuilder {
fn with_retry(self) -> RetriableRequestBuilder {
RetriableRequestBuilder {
inner: self,
backoff: default_retry_backoff(),
retry_if: RetriableRequestBuilder::is_retryable_error,
response_hook: None,
}
}
async fn send_json<T: DeserializeOwned + 'static>(self) -> Result<T> {
let (client, request, body_string) = build_and_extract_body(self)?;
let builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_json_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_json_response(resp, body_string).await
}
}
async fn send_xml<T: DeserializeOwned + 'static>(self) -> Result<T> {
let (client, request, body_string) = build_and_extract_body(self)?;
let builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_xml_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_xml_response(resp, body_string).await
}
}
async fn send_no_response(self) -> Result<()> {
let (client, request, body_string) = build_and_extract_body(self)?;
let builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_no_response(resp, body_string).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let resp =
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
handle_no_response(resp, body_string).await
}
}
async fn send_raw(self) -> Result<reqwest::Response> {
let (client, request, _body_string) = build_and_extract_body(self)?;
let builder = reqwest::RequestBuilder::from_parts(client, request);
#[cfg(target_arch = "wasm32")]
{
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})
}
#[cfg(not(target_arch = "wasm32"))]
{
builder
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})
}
}
}
pub struct InterceptedRequestBuilder {
inner: reqwest::RequestBuilder,
response_hook: Option<ResponseHook>,
}
impl InterceptedRequestBuilder {
pub fn new(inner: reqwest::RequestBuilder, response_hook: Option<ResponseHook>) -> Self {
Self {
inner,
response_hook,
}
}
pub fn with_retry(self) -> RetriableRequestBuilder {
RetriableRequestBuilder {
response_hook: self.response_hook,
..self.inner.with_retry()
}
}
pub async fn send_json<T: DeserializeOwned + 'static>(self) -> Result<T> {
let (resp, body_string) = self.send_once().await?;
handle_json_response(resp, body_string).await
}
pub async fn send_xml<T: DeserializeOwned + 'static>(self) -> Result<T> {
let (resp, body_string) = self.send_once().await?;
handle_xml_response(resp, body_string).await
}
pub async fn send_no_response(self) -> Result<()> {
let (resp, body_string) = self.send_once().await?;
handle_no_response(resp, body_string).await
}
pub async fn send_raw(self) -> Result<reqwest::Response> {
let (resp, _body_string) = self.send_once().await?;
Ok(resp)
}
pub fn build(self) -> reqwest::Result<reqwest::Request> {
self.inner.build()
}
pub fn into_parts(self) -> (reqwest::RequestBuilder, Option<ResponseHook>) {
(self.inner, self.response_hook)
}
async fn send_once(self) -> Result<(reqwest::Response, Option<String>)> {
let (client, request, body_string) = build_and_extract_body(self.inner)?;
let resp = reqwest::RequestBuilder::from_parts(client, request)
.send()
.await
.into_alien_error()
.context(ErrorData::HttpRequestFailed {
message: "Network error during HTTP request".to_string(),
})?;
let resp = apply_response_hook(self.response_hook.as_ref(), resp).await?;
Ok((resp, body_string))
}
}
#[cfg(test)]
mod tests {
use super::*;
use alien_error::ContextError;
use std::{
io::{BufRead, BufReader, Write},
net::TcpListener,
sync::{
atomic::{AtomicUsize, Ordering},
Arc,
},
thread,
};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
#[tokio::test]
async fn success_body_read_failure_does_not_replay_mutation() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("listen");
let address = listener.local_addr().expect("address");
let requests = Arc::new(AtomicUsize::new(0));
let seen = requests.clone();
let server = tokio::spawn(async move {
loop {
let (mut stream, _) = listener.accept().await.expect("accept");
{
let mut reader = tokio::io::BufReader::new(&mut stream);
loop {
let mut line = String::new();
assert!(reader.read_line(&mut line).await.expect("request header") > 0);
if line == "\r\n" {
break;
}
}
}
let request = seen.fetch_add(1, Ordering::SeqCst);
let response = if request == 0 {
&b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\nConnection: close\r\n\r\nshort"[..]
} else {
&b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"[..]
};
stream.write_all(response).await.expect("response");
stream.shutdown().await.expect("close response");
}
});
let error = reqwest::Client::builder()
.no_proxy()
.timeout(Duration::from_secs(5))
.build()
.expect("client")
.post(format!("http://{address}/mutation"))
.with_retry()
.backoff(
ExponentialBuilder::default()
.with_min_delay(Duration::from_millis(1))
.with_max_delay(Duration::from_millis(1))
.with_max_times(2),
)
.send_no_response()
.await
.expect_err("truncated body must fail");
assert_eq!(requests.load(Ordering::SeqCst), 1, "mutation was replayed");
assert!(!error.retryable);
assert_eq!(error.code, "HTTP_RESPONSE_BODY_READ_FAILED");
assert!(matches!(
error.error,
Some(ErrorData::HttpResponseBodyReadFailed { http_status: 200 })
));
server.abort();
assert!(server.await.expect_err("server stopped").is_cancelled());
}
#[tokio::test]
async fn rejects_truncated_success_response_body() {
let listener = TcpListener::bind("127.0.0.1:0").expect("listen");
let address = listener.local_addr().expect("address");
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().expect("accept");
{
let mut reader = BufReader::new(&mut stream);
loop {
let mut line = String::new();
assert!(reader.read_line(&mut line).expect("request header") > 0);
if line == "\r\n" {
break;
}
}
}
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\nConnection: close\r\n\r\nshort",
)
.expect("partial response");
});
let response = reqwest::Client::builder()
.no_proxy()
.timeout(Duration::from_secs(5))
.build()
.expect("client")
.get(format!("http://{address}/"))
.send()
.await
.expect("response headers");
assert_eq!(response.status(), reqwest::StatusCode::OK);
let error = handle_no_response(response, None)
.await
.expect_err("truncated body must fail");
assert_eq!(error.code, "HTTP_RESPONSE_BODY_READ_FAILED");
assert!(!error.retryable);
server.join().expect("server");
}
const SECRET: &str = "Sup3rSecret-MasterPassword!";
fn http_error_with_secret_body() -> AlienError<ErrorData> {
AlienError::new(ErrorData::HttpResponseError {
message: "Request failed with HTTP 409: Conflict".to_string(),
url: "https://rds.amazonaws.com/".to_string(),
http_status: 409,
http_request_text: Some(format!(
"Action=CreateDBCluster&MasterUserPassword={SECRET}&Engine=aurora-postgresql"
)),
http_response_text: Some(
"<Error><Code>DBClusterAlreadyExists</Code></Error>".to_string(),
),
})
}
#[test]
fn redacts_request_body_when_http_error_is_head() {
let raw = serde_json::to_string(&http_error_with_secret_body()).unwrap();
assert!(raw.contains(SECRET), "fixture should carry the secret");
let err = redact_request_body::<()>(Err(http_error_with_secret_body())).unwrap_err();
let json = serde_json::to_string(&err).expect("serialize redacted error");
assert!(!json.contains(SECRET), "request body leaked: {json}");
assert!(json.contains("409"), "status dropped: {json}");
assert!(
json.contains("DBClusterAlreadyExists"),
"response text dropped: {json}"
);
}
#[test]
fn redacts_request_body_when_http_error_is_wrapped_in_source() {
let wrapped = http_error_with_secret_body().context(ErrorData::RemoteResourceConflict {
resource_type: "DBCluster".to_string(),
resource_name: "stack-db".to_string(),
message: "already exists".to_string(),
});
let before = serde_json::to_string(&wrapped).unwrap();
assert!(
before.contains(SECRET),
"precondition: a non-internal head must NOT sanitize its source on its own"
);
let err = redact_request_body::<()>(Err(wrapped)).unwrap_err();
let json = serde_json::to_string(&err).expect("serialize redacted error");
assert!(
!json.contains(SECRET),
"request body leaked through source chain: {json}"
);
assert!(
json.contains("REMOTE_RESOURCE_CONFLICT"),
"head dropped: {json}"
);
assert!(
json.contains("DBClusterAlreadyExists"),
"response text dropped: {json}"
);
}
fn http_error_with_status(status: u16, response_text: &str) -> AlienError<ErrorData> {
AlienError::new(ErrorData::HttpResponseError {
message: "Invalid JSON response".to_string(),
url: "https://example.test/".to_string(),
http_status: status,
http_request_text: None,
http_response_text: Some(response_text.to_string()),
})
}
#[test]
fn redacts_the_body_of_an_unparsable_success_response() {
let wrapped = http_error_with_status(200, SECRET).context(ErrorData::GenericError {
message: "decrypt failed".to_string(),
});
let before = serde_json::to_string(&wrapped).unwrap();
assert!(before.contains(SECRET), "precondition: the chain holds it");
let err = redact_response_body::<()>(Err(wrapped)).unwrap_err();
let json = serde_json::to_string(&err).unwrap();
assert!(!json.contains(SECRET), "response body leaked: {json}");
assert!(json.contains("decrypt failed"), "chain dropped: {json}");
let head =
redact_response_body::<()>(Err(http_error_with_status(200, SECRET))).unwrap_err();
assert!(!serde_json::to_string(&head).unwrap().contains(SECRET));
}
#[derive(Debug, serde::Deserialize)]
#[allow(dead_code)]
struct DecryptResponse {
plaintext: String,
}
#[tokio::test]
async fn a_value_quoted_by_a_parse_error_does_not_reach_the_error_chain() {
let secret = "sentinel-parse-secret-value";
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("listen");
let address = listener.local_addr().expect("address");
let body = format!("\"{secret}\"");
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.expect("accept");
{
let mut reader = tokio::io::BufReader::new(&mut stream);
loop {
let mut line = String::new();
assert!(reader.read_line(&mut line).await.expect("request header") > 0);
if line == "\r\n" {
break;
}
}
}
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream
.write_all(response.as_bytes())
.await
.expect("response");
stream.shutdown().await.expect("close response");
});
let response = reqwest::Client::builder()
.no_proxy()
.timeout(Duration::from_secs(5))
.build()
.unwrap()
.get(format!("http://{address}/"))
.send()
.await
.unwrap();
let err = handle_json_response::<DecryptResponse>(response, None)
.await
.unwrap_err();
server.abort();
assert!(
serde_json::to_string(&err).unwrap().contains(secret),
"precondition: the parse error quotes the value"
);
let wrapped = err.context(ErrorData::GenericError {
message: "decrypt failed".to_string(),
});
let redacted = redact_response_body::<DecryptResponse>(Err(wrapped)).unwrap_err();
let json = serde_json::to_string(&redacted).unwrap();
assert!(!json.contains(secret), "parse message leaked: {json}");
assert!(json.contains("decrypt failed"), "chain dropped: {json}");
assert!(
json.contains("Invalid JSON response at field"),
"path dropped: {json}"
);
}
#[test]
fn keeps_the_body_of_an_error_response() {
let err = redact_response_body::<()>(Err(http_error_with_status(
403,
"AccessDeniedException: kms:Decrypt",
)))
.unwrap_err();
let json = serde_json::to_string(&err).unwrap();
assert!(json.contains("AccessDeniedException"), "{json}");
}
}