use std::fmt;
use http::header::{HeaderMap, HeaderName, HeaderValue};
use crate::error::{Error, Result};
pub(crate) const MAX_REQUEST_HEADER_BYTES: usize = 64 * 1024;
#[derive(Default, Clone)]
pub struct Headers {
inner: HeaderMap,
}
impl Headers {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, name: &str, value: &str) -> Result<()> {
validate_header_name(name)?;
validate_header_value(value)?;
let name =
HeaderName::try_from(name).map_err(|e| Error::InvalidHeaderName(e.to_string()))?;
let value =
HeaderValue::try_from(value).map_err(|e| Error::InvalidHeaderValue(e.to_string()))?;
self.inner.insert(name, value);
Ok(())
}
#[allow(
dead_code,
reason = "the raw-insert path is only reached from the multipart and redirect features, so it is dead code when neither is enabled"
)]
pub(crate) fn insert_raw(&mut self, name: HeaderName, value: HeaderValue) {
self.inner.insert(name, value);
}
pub fn append(&mut self, name: &str, value: &str) -> Result<()> {
validate_header_name(name)?;
validate_header_value(value)?;
let name =
HeaderName::try_from(name).map_err(|e| Error::InvalidHeaderName(e.to_string()))?;
let value =
HeaderValue::try_from(value).map_err(|e| Error::InvalidHeaderValue(e.to_string()))?;
self.inner.append(name, value);
Ok(())
}
#[must_use]
pub fn get(&self, name: &str) -> Option<&HeaderValue> {
self.inner.get(name)
}
#[must_use]
pub fn get_all(&self, name: &str) -> Vec<&HeaderValue> {
self.inner.get_all(name).iter().collect()
}
#[must_use]
pub fn get_str(
&self,
name: &str,
) -> Option<std::result::Result<&str, http::header::ToStrError>> {
self.inner.get(name).map(|v| v.to_str())
}
#[must_use]
pub fn contains(&self, name: &str) -> bool {
self.inner.contains_key(name)
}
#[must_use]
pub fn len(&self) -> usize {
self.inner.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&HeaderName, &HeaderValue)> {
self.inner.iter()
}
pub fn keys(&self) -> impl Iterator<Item = &HeaderName> {
self.inner.keys()
}
pub fn extend(&mut self, other: &Self) {
for name in other.inner.keys() {
for value in other.inner.get_all(name) {
self.inner.append(name.clone(), value.clone());
}
}
}
pub fn extend_replacing(&mut self, other: &Self) {
for name in other.inner.keys() {
self.inner.remove(name);
for value in other.inner.get_all(name) {
self.inner.append(name.clone(), value.clone());
}
}
}
pub fn remove(&mut self, name: &str) -> Option<HeaderValue> {
self.inner.remove(name)
}
#[must_use]
pub fn into_inner(self) -> HeaderMap {
self.inner
}
pub(crate) fn validate_request_size(
&self,
method: &http::Method,
request_target: &[u8],
) -> Result<()> {
let request_line_size = method
.as_str()
.len()
.checked_add(1)
.and_then(|size| size.checked_add(request_target.len()))
.and_then(|size| size.checked_add(1 + "HTTP/1.1".len() + 2));
let size = request_line_size.and_then(|size| {
self.inner.iter().try_fold(size, |size, (name, value)| {
size.checked_add(name.as_str().len() + value.as_bytes().len() + 4)
})
});
if size.is_none_or(|size| {
size.checked_add(2)
.is_none_or(|size| size > MAX_REQUEST_HEADER_BYTES)
}) {
return Err(Error::RequestBuild(format!(
"request headers exceed maximum size of {MAX_REQUEST_HEADER_BYTES} bytes"
)));
}
Ok(())
}
pub(crate) fn validate_request_size_uri(
&self,
method: &http::Method,
request_target: &http::Uri,
) -> Result<()> {
struct CountWriter(usize);
impl fmt::Write for CountWriter {
fn write_str(&mut self, value: &str) -> fmt::Result {
self.0 = self.0.checked_add(value.len()).ok_or(fmt::Error)?;
Ok(())
}
}
let mut writer = CountWriter(0);
fmt::write(&mut writer, format_args!("{request_target}"))
.map_err(|_| Error::RequestBuild("request target serialization overflowed".into()))?;
self.validate_request_size_len(method, writer.0)
}
fn validate_request_size_len(&self, method: &http::Method, target_len: usize) -> Result<()> {
let request_line_size = method
.as_str()
.len()
.checked_add(1)
.and_then(|size| size.checked_add(target_len))
.and_then(|size| size.checked_add(1 + "HTTP/1.1".len() + 2));
let size = request_line_size.and_then(|size| {
self.inner.iter().try_fold(size, |size, (name, value)| {
size.checked_add(name.as_str().len() + value.as_bytes().len() + 4)
})
});
if size.is_none_or(|size| {
size.checked_add(2)
.is_none_or(|size| size > MAX_REQUEST_HEADER_BYTES)
}) {
return Err(Error::RequestBuild(format!(
"request headers exceed maximum size of {MAX_REQUEST_HEADER_BYTES} bytes"
)));
}
Ok(())
}
}
impl From<HeaderMap> for Headers {
fn from(inner: HeaderMap) -> Self {
Self { inner }
}
}
impl fmt::Debug for Headers {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut debug = f.debug_map();
for (name, value) in &self.inner {
if crate::redact::is_sensitive_header(name.as_str()) {
debug.entry(&name, &"<redacted>");
} else {
debug.entry(&name, &value);
}
}
debug.finish()
}
}
fn validate_header_name(name: &str) -> Result<()> {
if name.is_empty() {
return Err(Error::InvalidHeaderName(
"header name must not be empty".into(),
));
}
if name.contains('\n') || name.contains('\r') {
return Err(Error::InvalidHeaderName(
"header name must not contain newlines".into(),
));
}
Ok(())
}
fn validate_header_value(value: &str) -> Result<()> {
if value
.bytes()
.any(|byte| (byte < 0x20 && byte != b'\t') || byte == 0x7f)
{
return Err(Error::InvalidHeaderValue(
"header value must not contain control characters".into(),
));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
#[test]
fn insert_and_get() {
let mut h = Headers::new();
h.insert("X-Custom", "value1").unwrap();
assert_eq!(h.get("x-custom").unwrap().to_str().unwrap(), "value1");
}
#[test]
fn append_duplicates() {
let mut h = Headers::new();
h.append("Set-Cookie", "a=1").unwrap();
h.append("Set-Cookie", "b=2").unwrap();
let values: Vec<_> = h.inner.get_all("set-cookie").iter().collect();
assert_eq!(values.len(), 2);
}
#[test]
fn extend_preserves_duplicate_values() {
let mut first = Headers::new();
first.append("Set-Cookie", "a=1").unwrap();
let mut second = Headers::new();
second.append("Set-Cookie", "b=2").unwrap();
first.extend(&second);
let values: Vec<_> = first.inner.get_all("set-cookie").iter().collect();
assert_eq!(values.len(), 2);
}
#[test]
fn contains() {
let mut h = Headers::new();
h.insert("Content-Type", "text/plain").unwrap();
assert!(h.contains("content-type"));
assert!(!h.contains("x-missing"));
}
#[test]
fn empty_name_rejected() {
let mut h = Headers::new();
assert!(h.insert("", "value").is_err());
}
#[test]
fn newline_in_name_rejected() {
let mut h = Headers::new();
assert!(h.insert("X-Bad\n", "value").is_err());
}
#[test]
fn newline_in_value_rejected() {
let mut h = Headers::new();
assert!(h.insert("X-Bad", "value\r\ninjection").is_err());
}
#[test]
fn control_characters_in_value_rejected() {
for value in ["value\0", "value\x1f", "value\x7f"] {
let mut h = Headers::new();
assert!(h.insert("X-Bad", value).is_err());
}
}
#[test]
fn horizontal_tab_in_value_allowed() {
let mut h = Headers::new();
assert!(h.insert("X-Test", "value\twith-tab").is_ok());
}
#[test]
fn from_headermap() {
let mut hm = HeaderMap::new();
hm.insert("X-Test", HeaderValue::from_static("hello"));
let h = Headers::from(hm);
assert_eq!(h.get("x-test").unwrap().to_str().unwrap(), "hello");
}
#[test]
fn uri_size_validation_matches_display_length() {
let headers = Headers::new();
for target in [
"http://example.com/path?q=1",
"/origin-form?q=1",
"*",
"https://example.com:8443/absolute",
] {
let uri: http::Uri = target.parse().unwrap();
assert_eq!(uri.to_string().len(), target.len());
headers
.validate_request_size_uri(&http::Method::GET, &uri)
.unwrap();
}
}
#[test]
fn request_header_size_is_bounded() {
let mut headers = Headers::new();
headers
.insert("x-large", &"x".repeat(MAX_REQUEST_HEADER_BYTES))
.unwrap();
assert!(headers
.validate_request_size(&http::Method::GET, b"/")
.is_err());
let headers = Headers::new();
let target = vec![b'/'; MAX_REQUEST_HEADER_BYTES];
assert!(headers
.validate_request_size(&http::Method::GET, &target)
.is_err());
}
proptest::proptest! {
#[test]
fn round_trip_insert_get(name in "[a-zA-Z][a-zA-Z0-9_-]{0,20}", value in "[a-zA-Z0-9 ]{1,30}") {
let mut h = Headers::new();
h.insert(&name, &value).unwrap();
let got = h.get_str(&name).unwrap().unwrap();
prop_assert_eq!(got, value.as_str());
}
#[test]
fn insert_replaces_previous(name in "[a-zA-Z][a-zA-Z0-9_-]{0,20}", v1 in "[a-z]{1,10}", v2 in "[a-z]{1,10}") {
let mut h = Headers::new();
h.insert(&name, &v1).unwrap();
h.insert(&name, &v2).unwrap();
let got = h.get_str(&name).unwrap().unwrap();
prop_assert_eq!(got, v2.as_str());
}
#[test]
fn append_preserves_all(name in "[a-zA-Z][a-zA-Z0-9_-]{0,20}", values in proptest::collection::vec("[a-z]{1,10}", 1..5)) {
let mut h = Headers::new();
for v in &values {
h.append(&name, v).unwrap();
}
let all = h.get_all(&name);
prop_assert_eq!(all.len(), values.len());
}
#[test]
fn contains_after_insert(name in "[a-zA-Z][a-zA-Z0-9_-]{0,20}", value in "[a-z]{1,10}") {
let mut h = Headers::new();
prop_assert!(!h.contains(&name));
h.insert(&name, &value).unwrap();
prop_assert!(h.contains(&name));
}
#[test]
fn prop_empty_name_rejected(value in "[a-z]{1,10}") {
let mut h = Headers::new();
prop_assert!(h.insert("", &value).is_err());
}
#[test]
fn prop_newline_in_name_rejected(name in "[a-zA-Z][a-zA-Z0-9_-]{0,10}", value in "[a-z]{1,10}") {
let mut h = Headers::new();
let bad_name = format!("{name}\n");
prop_assert!(h.insert(&bad_name, &value).is_err());
}
#[test]
fn prop_newline_in_value_rejected(name in "[a-zA-Z][a-zA-Z0-9_-]{0,10}", value in "[a-z]{1,10}") {
let mut h = Headers::new();
let bad_value = format!("{value}\r\ninjection");
prop_assert!(h.insert(&name, &bad_value).is_err());
}
}
}