use crate::config::GarrisonConfig;
use crate::error::GarrisonError;
use http::HeaderMap;
pub trait HeaderLookup {
fn get_header(&self, name: &str) -> Option<&str>;
}
impl HeaderLookup for HeaderMap {
fn get_header(&self, name: &str) -> Option<&str> {
self.get(name).and_then(|v| v.to_str().ok())
}
}
pub fn strip_bearer_prefix(auth_str: &str) -> Option<&str> {
let prefix = "bearer ";
let head = auth_str.get(..prefix.len())?;
if head.eq_ignore_ascii_case(prefix) {
Some(&auth_str[prefix.len()..])
} else {
None
}
}
pub fn is_body_token_allowed_method(method: &str) -> bool {
method.eq_ignore_ascii_case("POST")
|| method.eq_ignore_ascii_case("PUT")
|| method.eq_ignore_ascii_case("PATCH")
}
pub fn extract_token_from_headers<H: HeaderLookup>(
headers: &H,
config: &GarrisonConfig,
) -> Result<Option<String>, GarrisonError> {
if config.is_read_header {
if let Some(auth) = headers.get_header("authorization") {
if let Some(token) = strip_bearer_prefix(auth) {
return Ok(Some(token.to_string()));
}
}
if let Some(token) = headers.get_header(&config.token_name) {
return Ok(Some(token.to_string()));
}
}
if config.is_read_cookie {
let cookie_header = headers.get_header("cookie").unwrap_or("");
if !cookie_header.is_empty() {
for cookie in cookie_header.split(';') {
let cookie = cookie.trim();
if let Some(eq_pos) = cookie.find('=') {
let (k, v) = cookie.split_at(eq_pos);
if k == config.token_name {
return Ok(Some(v[1..].to_string()));
}
}
}
}
}
Ok(None)
}
#[cfg(test)]
mod tests {
use super::*;
use http::header;
use http::HeaderValue;
#[test]
fn strip_bearer_prefix_standard() {
assert_eq!(strip_bearer_prefix("Bearer my_token"), Some("my_token"));
}
#[test]
fn strip_bearer_prefix_lowercase() {
assert_eq!(strip_bearer_prefix("bearer my_token"), Some("my_token"));
}
#[test]
fn strip_bearer_prefix_uppercase() {
assert_eq!(strip_bearer_prefix("BEARER my_token"), Some("my_token"));
}
#[test]
fn strip_bearer_prefix_mixed_case() {
assert_eq!(strip_bearer_prefix("BeArEr my_token"), Some("my_token"));
}
#[test]
fn strip_bearer_prefix_no_prefix() {
assert_eq!(strip_bearer_prefix("my_token"), None);
assert_eq!(strip_bearer_prefix("Basic abc123"), None);
}
#[test]
fn strip_bearer_prefix_empty() {
assert_eq!(strip_bearer_prefix(""), None);
}
#[test]
fn strip_bearer_prefix_shorter_than_prefix() {
assert_eq!(strip_bearer_prefix("Bear"), None);
assert_eq!(strip_bearer_prefix("bearer"), None);
}
#[test]
fn strip_bearer_prefix_multibyte_no_panic() {
let auth_str = "éééé"; assert_eq!(strip_bearer_prefix(auth_str), None);
}
#[test]
fn strip_bearer_prefix_only_prefix() {
assert_eq!(strip_bearer_prefix("Bearer "), Some(""));
}
#[test]
fn extract_token_from_bearer_header() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer my_token_123"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("my_token_123".to_string()));
}
#[test]
fn extract_token_bearer_case_insensitive() {
let config = GarrisonConfig::default_config();
for prefix in &["Bearer", "bearer", "BEARER", "BeArEr"] {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_str(&format!("{} tok_{}", prefix, prefix)).unwrap(),
);
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(
token,
Some(format!("tok_{}", prefix)),
"前缀 '{}' 应能提取 token",
prefix
);
}
}
#[test]
fn extract_token_from_custom_token_name_header() {
let mut headers = HeaderMap::new();
headers.insert(
"garrison_token",
HeaderValue::from_static("custom_header_tok"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("custom_header_tok".to_string()));
}
#[test]
fn extract_token_from_cookie() {
let mut headers = HeaderMap::new();
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok_456"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("cookie_tok_456".to_string()));
}
#[test]
fn extract_token_returns_none_when_missing() {
let headers = HeaderMap::new();
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, None);
}
#[test]
fn extract_token_bearer_priority_over_cookie() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("header_tok".to_string()));
}
#[test]
fn extract_token_custom_header_priority_over_cookie() {
let mut headers = HeaderMap::new();
headers.insert(
"garrison_token",
HeaderValue::from_static("custom_header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("custom_header_tok".to_string()));
}
#[test]
fn extract_token_skips_header_when_disabled() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("cookie_tok".to_string()));
}
#[test]
fn extract_token_skips_cookie_when_disabled() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let mut config = GarrisonConfig::default_config();
config.is_read_cookie = false;
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("header_tok".to_string()));
}
#[test]
fn extract_token_returns_none_when_both_disabled() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, None);
}
#[test]
fn extract_token_from_cookie_with_multiple_pairs() {
let mut headers = HeaderMap::new();
headers.insert(
header::COOKIE,
HeaderValue::from_static("session=abc; garrison_token=target_tok; other=val"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("target_tok".to_string()));
}
#[test]
fn extract_token_falls_back_when_no_bearer_prefix() {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Basic abc123"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("cookie_tok".to_string()));
}
#[test]
fn c7_is_body_token_allowed_method_post() {
assert!(is_body_token_allowed_method("POST"));
}
#[test]
fn c7_is_body_token_allowed_method_put_patch() {
assert!(is_body_token_allowed_method("PUT"));
assert!(is_body_token_allowed_method("PATCH"));
}
#[test]
fn c7_is_body_token_allowed_method_rejects_others() {
assert!(!is_body_token_allowed_method("GET"));
assert!(!is_body_token_allowed_method("HEAD"));
assert!(!is_body_token_allowed_method("DELETE"));
assert!(!is_body_token_allowed_method("OPTIONS"));
assert!(!is_body_token_allowed_method("CONNECT"));
assert!(!is_body_token_allowed_method("TRACE"));
}
#[test]
fn c7_is_body_token_allowed_method_case_insensitive_and_edge() {
assert!(is_body_token_allowed_method("post"));
assert!(is_body_token_allowed_method("Put"));
assert!(is_body_token_allowed_method("pAtCh"));
assert!(is_body_token_allowed_method("PoSt"));
assert!(!is_body_token_allowed_method(""));
assert!(!is_body_token_allowed_method("unknown"));
assert!(!is_body_token_allowed_method("POST ")); assert!(!is_body_token_allowed_method(" POST")); }
}