use std::borrow::Cow;
use std::fmt;
use base64::Engine;
const CONTEXT_CHARS: usize = 80;
const MAX_CONTEXT_BYTES: usize = 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SecretSeverity {
Critical,
High,
Medium,
Low,
}
impl SecretSeverity {
pub fn as_str(self) -> &'static str {
match self {
SecretSeverity::Critical => "critical",
SecretSeverity::High => "high",
SecretSeverity::Medium => "medium",
SecretSeverity::Low => "low",
}
}
}
impl fmt::Display for SecretSeverity {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone)]
pub struct ExposedSecret {
pub secret_type: String,
pub matched_value: String,
pub context: String,
pub severity: SecretSeverity,
pub location: Cow<'static, str>,
pub decoded_jwt: Option<crate::parse::jwt::DecodedJwt>,
}
fn shannon_entropy(s: &str) -> f64 {
if s.is_empty() {
return 0.0;
}
let mut counts = [0u64; 256];
for b in s.bytes() {
counts[usize::from(b)] += 1;
}
#[allow(clippy::cast_precision_loss)] let len = s.len() as f64;
let mut entropy = 0.0;
for &c in &counts {
if c > 0 {
#[allow(clippy::cast_precision_loss)]
let p = c as f64 / len;
entropy -= p * p.log2();
}
}
entropy
}
const GENERIC_API_KEY_MIN_ENTROPY: f64 = 4.0;
const GENERIC_API_KEY_HEX_MIN_ENTROPY: f64 = 3.5;
const GENERIC_API_KEY_MIN_LEN: usize = 16;
const GENERIC_API_KEY_HEX_MIN_LEN: usize = 32;
fn looks_like_camel_case_identifier(s: &str) -> bool {
let bytes = s.as_bytes();
for window in bytes.windows(2) {
if window[0].is_ascii_lowercase() && window[1].is_ascii_uppercase() {
return true;
}
}
false
}
fn looks_like_hyphenated_uuid(s: &str) -> bool {
let b = s.as_bytes();
if b.len() != 36 {
return false;
}
if b[8] != b'-' || b[13] != b'-' || b[18] != b'-' || b[23] != b'-' {
return false;
}
b.iter()
.enumerate()
.all(|(i, c)| matches!(i, 8 | 13 | 18 | 23) || c.is_ascii_hexdigit())
}
fn generic_api_key_is_plausible(value: &str) -> bool {
if value.len() < GENERIC_API_KEY_MIN_LEN {
return false;
}
if looks_like_hyphenated_uuid(value) {
return false;
}
if value.contains('.') || value.contains('=') {
return false;
}
if looks_like_camel_case_identifier(value) {
return false;
}
if !value
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_' || b == b'+' || b == b'/')
{
return false;
}
if value.bytes().all(|b| b.is_ascii_alphabetic()) {
return false;
}
let hex_digits = value.bytes().filter(|b| b.is_ascii_hexdigit()).count();
let predominantly_hex = hex_digits * 5 >= value.len() * 4; if predominantly_hex {
if value.len() < GENERIC_API_KEY_HEX_MIN_LEN {
return false;
}
return shannon_entropy(value) >= GENERIC_API_KEY_HEX_MIN_ENTROPY;
}
shannon_entropy(value) >= GENERIC_API_KEY_MIN_ENTROPY
}
fn web_rule_match_is_plausible(rule_id: &str, matched_value: &str) -> bool {
match rule_id {
"generic-api-key" => generic_api_key_is_plausible(matched_value),
"sourcegraph-access-token" => matched_value.starts_with("sgp_"),
"vault-service-token" => {
if let Some(rest) = matched_value.strip_prefix("s.") {
!looks_like_camel_case_identifier(rest)
} else {
true
}
}
"linkedin-client-id" | "linkedin-client-secret" => {
let starts_lower = matched_value
.chars()
.next()
.is_some_and(|c| c.is_ascii_lowercase());
!(starts_lower && looks_like_camel_case_identifier(matched_value))
}
"private-key" => private_key_body_is_plausible(matched_value),
"http-basic-auth" => http_basic_auth_is_plausible(matched_value),
_ => true,
}
}
fn web_rule_match_is_plausible_in_context(
rule_id: &str,
matched_value: &str,
nearby_text: &str,
full_match: &str,
line_content: &str,
) -> bool {
match rule_id {
"datadog-access-token" => nearby_text_looks_like_datadog(nearby_text),
"credential-bearing-url" => {
credential_bearing_url_is_plausible(matched_value, full_match, line_content)
}
_ => true,
}
}
fn nearby_text_looks_like_datadog(nearby_text: &str) -> bool {
let lower = nearby_text.to_ascii_lowercase();
const MARKERS: &[&str] = &[
"datadog",
"dd_api",
"dd_app",
"ddapikey",
"ddappkey",
"dd_rum",
"dd_logs",
"dd_client",
"dd_site",
];
MARKERS.iter().any(|m| lower.contains(m))
}
const DISTINCTIVE_USERINFO_PREFIXES: &[&str] = &["ghp_", "glpat-", "sk_", "xox", "AKIA"];
fn captured_has_distinctive_userinfo_prefix(value: &str) -> bool {
DISTINCTIVE_USERINFO_PREFIXES
.iter()
.any(|prefix| value.starts_with(prefix))
}
fn credential_bearing_url_is_plausible(
matched_value: &str,
full_match: &str,
line_content: &str,
) -> bool {
if captured_has_distinctive_userinfo_prefix(matched_value) {
return true;
}
if line_content.to_ascii_lowercase().contains("mailto:") {
return false;
}
if userinfo_user_is_mailbox_shaped(full_match) {
return false;
}
if !full_match_userinfo_has_colon(full_match) {
return false;
}
true
}
fn full_match_userinfo_has_colon(full_match: &str) -> bool {
let Some((_, rest)) = full_match.split_once("://") else {
return false;
};
rest.split('@')
.next()
.is_some_and(|userinfo| userinfo.contains(':'))
}
fn userinfo_user_is_mailbox_shaped(full_match: &str) -> bool {
let Some((_, rest)) = full_match.split_once("://") else {
return false;
};
let Some(userinfo) = rest.split('@').next() else {
return false;
};
let user = userinfo.split(':').next().unwrap_or(userinfo);
let lower = user.to_ascii_lowercase();
let Some(at) = lower.find("%40") else {
return false;
};
let local = &lower[..at];
let domain = &lower[at + 3..];
!local.is_empty()
&& domain.contains('.')
&& domain
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'.' || b == b'-')
}
const PRIVATE_KEY_MIN_DECODED_BODY: usize = 64;
fn private_key_body_is_plausible(pem: &str) -> bool {
pem_decoded_body_len(pem) >= PRIVATE_KEY_MIN_DECODED_BODY
}
fn pem_decoded_body_len(pem: &str) -> usize {
let Some(b64) = pem_base64_body(pem) else {
return 0;
};
match base64::engine::general_purpose::STANDARD.decode(b64.as_bytes()) {
Ok(bytes) => bytes.len(),
Err(_) if b64.len() >= 86 => b64.len().saturating_mul(3) / 4,
Err(_) => 0,
}
}
fn pem_base64_body(pem: &str) -> Option<String> {
let begin = pem.find("-----BEGIN")?;
let after_first_dashes = pem.get(begin + 5..)?;
let header_end_rel = after_first_dashes.find("-----")?;
let body_start = begin + 5 + header_end_rel + 5;
let rest = pem.get(body_start..)?;
let body_end = rest
.find("-----END")
.or_else(|| rest.rfind("KEY-----"))
.unwrap_or(rest.len());
let raw = rest.get(..body_end)?;
let b64: String = raw
.chars()
.filter(|c| c.is_ascii_alphanumeric() || matches!(*c, '+' | '/' | '='))
.collect();
if b64.is_empty() {
None
} else {
Some(b64)
}
}
const HTTP_BASIC_MIN_DECODED_LEN: usize = 10;
fn http_basic_auth_is_plausible(matched_value: &str) -> bool {
let Some(bytes) = decode_http_basic(matched_value) else {
return false;
};
if bytes.len() < HTTP_BASIC_MIN_DECODED_LEN {
return false;
}
let Ok(decoded) = std::str::from_utf8(&bytes) else {
return true;
};
let Some((user, pass)) = decoded.split_once(':') else {
return false;
};
!http_basic_pair_is_placeholder(user, pass)
}
fn decode_http_basic(value: &str) -> Option<Vec<u8>> {
let trimmed = value.trim();
base64::engine::general_purpose::STANDARD
.decode(trimmed.as_bytes())
.ok()
.or_else(|| {
base64::engine::general_purpose::STANDARD_NO_PAD
.decode(trimmed.as_bytes())
.ok()
})
}
fn http_basic_pair_is_placeholder(user: &str, pass: &str) -> bool {
const USERS: &[&str] = &["user", "foo", "bar", "beep", "admin"];
const PASSES: &[&str] = &["pass", "password", "foo", "bar", "beep", "boop"];
let user = user.to_ascii_lowercase();
let pass = pass.to_ascii_lowercase();
USERS.contains(&user.as_str()) && PASSES.contains(&pass.as_str())
}
fn severity_for_rule_id(rule_id: &str) -> SecretSeverity {
match rule_id {
"private-key"
| "database-connection-uri"
| "jdbc-connection-string"
| "credential-bearing-url"
| "slack-bot-token"
| "slack-user-token"
| "slack-legacy-token"
| "slack-legacy-bot-token"
| "github-pat"
| "github-fine-grained-pat"
| "gitlab-pat"
| "vault-batch-token"
| "vault-service-token" => SecretSeverity::Critical,
"aws-access-token"
| "http-basic-auth"
| "mailchimp-api-key"
| "openai-api-key"
| "anthropic-api-key"
| "anthropic-admin-api-key"
| "sendgrid-api-token"
| "twilio-api-key"
| "npm-access-token"
| "pypi-upload-token"
| "digitalocean-access-token"
| "digitalocean-pat"
| "heroku-api-key"
| "heroku-api-key-v2"
| "flyio-access-token"
| "shopify-access-token"
| "shopify-private-app-access-token"
| "shopify-shared-secret"
| "bitbucket-client-secret"
| "mailgun-private-api-token"
| "cloudflare-api-key"
| "doppler-api-token"
| "plaid-secret-key"
| "plaid-api-token"
| "fastly-api-token" => SecretSeverity::High,
"azure-ad-client-secret"
| "slack-webhook-url"
| "slack-app-token"
| "algolia-api-key"
| "datadog-access-token"
| "grafana-api-key"
| "grafana-cloud-api-token"
| "sentry-access-token"
| "linear-api-key"
| "generic-api-key" => SecretSeverity::Medium,
"gcp-api-key" | "mapbox-api-token" | "contentful-delivery-api-token" => {
SecretSeverity::Low
}
"jwt" | "jwt-base64" => SecretSeverity::Low,
_ => severity_for_unknown_rule_id(rule_id),
}
}
fn algolia_assignment_is_admin(nearby_text: &str) -> bool {
let lower = nearby_text.to_ascii_lowercase();
const MARKERS: &[&str] = &[
"admin_key",
"adminkey",
"adminapikey",
"admin_api_key",
"algolia_admin",
"algoliaadmin",
];
MARKERS.iter().any(|m| lower.contains(m))
}
fn severity_for_finding(rule_id: &str, line_content: &str, nearby_text: &str) -> SecretSeverity {
let severity = severity_for_rule_id(rule_id);
if rule_id == "aws-access-token"
&& line_content
.to_ascii_lowercase()
.contains("x-amz-credential=")
{
return SecretSeverity::Low;
}
if rule_id == "algolia-api-key" && !algolia_assignment_is_admin(nearby_text) {
return SecretSeverity::Low;
}
severity
}
fn severity_for_unknown_rule_id(rule_id: &str) -> SecretSeverity {
let lower = rule_id;
if lower.contains("private-key")
|| lower.contains("password")
|| lower.contains("client-secret")
|| lower.contains("client_secret")
{
SecretSeverity::High
} else if lower.contains("token")
|| lower.contains("api-key")
|| lower.contains("api_key")
|| lower.contains("access-key")
|| lower.contains("access_key")
|| lower.contains("secret")
|| lower.contains("pat")
|| lower.contains("cred")
{
SecretSeverity::Medium
} else {
SecretSeverity::Low
}
}
fn global_allowlist_skips(
global: &crate::parse::gitleaks::CompiledGlobalAllowlist,
matched_value: &str,
) -> bool {
for re in &global.regexes {
if re.is_match(matched_value) {
return true;
}
}
for word in &global.stopwords {
if matched_value.contains(word) {
return true;
}
}
false
}
const MAX_LINE_WINDOW_BYTES: usize = 512;
fn line_containing(body: &str, start: usize, end: usize) -> &str {
let mut window_start = start.saturating_sub(MAX_LINE_WINDOW_BYTES);
while !body.is_char_boundary(window_start) {
window_start += 1;
}
let mut window_end = (end + MAX_LINE_WINDOW_BYTES).min(body.len());
while !body.is_char_boundary(window_end) {
window_end -= 1;
}
let line_start = body[window_start..start]
.rfind('\n')
.map_or(window_start, |i| window_start + i + 1);
let line_end = body[end..window_end]
.find('\n')
.map_or(window_end, |i| end + i);
&body[line_start..line_end]
}
fn extract_secret(
captures: Option<regex::Captures>,
full_match: &str,
secret_group: Option<u32>,
) -> String {
let Some(caps) = captures else {
return full_match.to_string();
};
if let Some(n) = secret_group {
if n > 0 {
if let Some(m) = caps.get(n as usize) {
return m.as_str().to_string();
}
}
}
for i in 1..caps.len() {
if let Some(m) = caps.get(i) {
if !m.as_str().is_empty() {
return m.as_str().to_string();
}
}
}
full_match.to_string()
}
pub(crate) fn rule_allowlist_skips(
allowlists: &[crate::parse::gitleaks::CompiledRuleAllowlist],
matched_value: &str,
line_content: &str,
full_match: &str,
) -> bool {
for list in allowlists {
let target = match list.regex_target.as_deref() {
Some("line") => line_content,
Some("match") => full_match,
_ => matched_value,
};
if list.condition_and {
if list.has_paths {
continue; }
let all_regex =
list.regexes.is_empty() || list.regexes.iter().all(|re| re.is_match(target));
let all_stop =
list.stopwords.is_empty() || list.stopwords.iter().all(|w| target.contains(w));
if all_regex && all_stop {
return true;
}
} else {
for re in &list.regexes {
if re.is_match(target) {
return true;
}
}
for word in &list.stopwords {
if target.contains(word) {
return true;
}
}
}
}
false
}
fn extract_context(body: &str, start: usize, end: usize) -> String {
let ctx_start = start.saturating_sub(CONTEXT_CHARS);
let ctx_end = (end + CONTEXT_CHARS).min(body.len());
let safe_start = (0..=ctx_start)
.rev()
.find(|&i| body.is_char_boundary(i))
.unwrap_or(0);
let safe_end = (ctx_end..=body.len())
.find(|&i| body.is_char_boundary(i))
.unwrap_or(body.len());
let raw = &body[safe_start..safe_end];
if raw.len() <= MAX_CONTEXT_BYTES {
return raw.to_string();
}
const ELLIPSIS: &str = "...[truncated]...";
let prefix = match_safe_slice(body, safe_start, start);
let suffix = match_safe_slice(body, end, safe_end);
let prefix_len = prefix.len();
let suffix_len = suffix.len();
let overhead = prefix_len + suffix_len + ELLIPSIS.len();
if overhead >= MAX_CONTEXT_BYTES {
return truncate_at_char_boundary(raw, MAX_CONTEXT_BYTES);
}
let match_budget = MAX_CONTEXT_BYTES - overhead;
let half = match_budget / 2;
let match_text = &body[start..end];
let head = truncate_at_char_boundary(match_text, half);
let tail_start = match_text
.len()
.saturating_sub(match_budget - head.len())
.max(head.len());
let tail_start = (tail_start..=match_text.len())
.find(|&i| match_text.is_char_boundary(i))
.unwrap_or(match_text.len());
let tail = &match_text[tail_start..];
format!("{prefix}{head}{ELLIPSIS}{tail}{suffix}")
}
fn match_safe_slice(body: &str, start: usize, end: usize) -> &str {
if start <= end
&& end <= body.len()
&& body.is_char_boundary(start)
&& body.is_char_boundary(end)
{
&body[start..end]
} else {
""
}
}
fn truncate_at_char_boundary(s: &str, max_bytes: usize) -> String {
if s.len() <= max_bytes {
return s.to_string();
}
let mut idx = max_bytes;
while idx > 0 && !s.is_char_boundary(idx) {
idx -= 1;
}
s[..idx].to_string()
}
fn infer_location(context: &str) -> &'static str {
let ctx = context.to_lowercase();
if ctx.contains("<script") || ctx.contains("</script") {
"inline_script"
} else if ctx.contains("<!--") {
"html_comment"
} else if ctx.contains("data-") {
"data_attribute"
} else if ctx.contains("?key=")
|| ctx.contains("&key=")
|| ctx.contains("&token=")
|| ctx.contains("?token=")
{
"url_parameter"
} else if ctx.contains("content=\"") || ctx.contains("content='") {
"meta_tag"
} else {
"html_body"
}
}
fn is_inside_json_ld_script(body: &str, pos: usize) -> bool {
let before = &body[..pos.min(body.len())];
let lower_before = before.to_ascii_lowercase();
let Some(script_start) = lower_before.rfind("<script") else {
return false;
};
let region = &lower_before[script_start..];
if let Some(close) = region.find("</script") {
if script_start + close < pos {
return false;
}
}
let tag_end = region.find('>').unwrap_or(region.len().min(200));
region[..tag_end].contains("application/ld+json")
}
fn infer_location_for_body_match(body: &str, match_start: usize, context: &str) -> &'static str {
if is_inside_json_ld_script(body, match_start) {
return "json_ld";
}
infer_location(context)
}
pub fn detect_exposed_secrets(body: &str) -> Vec<ExposedSecret> {
detect_exposed_secrets_inner(body, true)
}
pub fn detect_exposed_secrets_in_headers(header_block: &str) -> Vec<ExposedSecret> {
let mut found = detect_exposed_secrets_inner(header_block, true);
for secret in &mut found {
let ctx_lc = secret.context.to_ascii_lowercase();
if ctx_lc.contains("set-cookie:") {
secret.location = Cow::Borrowed("set_cookie");
} else {
secret.location = Cow::Borrowed("response_header");
}
}
found
}
#[cfg(test)]
pub(crate) fn detect_exposed_secrets_unfiltered(body: &str) -> Vec<ExposedSecret> {
detect_exposed_secrets_inner(body, false)
}
fn detect_exposed_secrets_inner(body: &str, use_prefilter: bool) -> Vec<ExposedSecret> {
let config = crate::parse::gitleaks::gitleaks();
let mut results = Vec::new();
let mut seen = std::collections::HashSet::new();
let matched_keyword_ids = if use_prefilter {
config
.keyword_prefilter
.as_ref()
.map(|p| p.matched_pattern_ids(body))
} else {
None
};
for rule in &config.rules {
if rule.path.is_some() {
continue;
}
if let (Some(ids), Some(matched)) = (
rule.keyword_pattern_ids.as_ref(),
matched_keyword_ids.as_ref(),
) {
if !ids.is_empty()
&& !crate::parse::gitleaks::KeywordPrefilter::any_id_present(ids, matched)
{
continue;
}
}
for cap in rule.regex.captures_iter(body) {
let Some(mat) = cap.get(0) else { continue };
let full_match = mat.as_str();
let matched_value = extract_secret(Some(cap), full_match, rule.secret_group);
if let Some(entropy_threshold) = rule.entropy {
if shannon_entropy(&matched_value) < entropy_threshold {
continue;
}
}
if global_allowlist_skips(&config.global_allowlist, &matched_value) {
continue;
}
if !web_rule_match_is_plausible(&rule.id, &matched_value) {
continue;
}
let context = extract_context(body, mat.start(), mat.end());
let line_content = line_containing(body, mat.start(), mat.end());
if !web_rule_match_is_plausible_in_context(
&rule.id,
&matched_value,
&context,
full_match,
line_content,
) {
continue;
}
if rule_allowlist_skips(&rule.allowlists, &matched_value, line_content, full_match) {
continue;
}
let key = (rule.id.clone(), matched_value.clone());
if !seen.insert(key) {
continue;
}
let location: Cow<'static, str> =
Cow::Borrowed(infer_location_for_body_match(body, mat.start(), &context));
let severity = severity_for_finding(&rule.id, line_content, &context);
let decoded_jwt = match rule.id.as_str() {
"jwt" => crate::parse::jwt::decode_jwt(&matched_value),
"jwt-base64" => crate::parse::jwt::decode_jwt_base64(&matched_value),
_ => None,
};
results.push(ExposedSecret {
secret_type: rule.id.clone(),
matched_value,
context,
severity,
location,
decoded_jwt,
});
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
const AWS_KEY: &str = "AKIAIOSFODNN7EXAMPL2";
#[test]
fn test_detect_aws_access_key() {
let body = format!(r#"var key = "{}";"#, AWS_KEY);
let secrets = detect_exposed_secrets(&body);
let aws = secrets
.iter()
.find(|s| s.secret_type == "aws-access-token")
.unwrap_or_else(|| panic!("expected an aws-access-token secret in {secrets:?}"));
assert_eq!(aws.matched_value, AWS_KEY);
assert_eq!(aws.severity, SecretSeverity::High);
}
#[test]
fn test_aws_example_allowlisted() {
let body = r#"var key = "AKIAIOSFODNN7EXAMPLE";"#;
let secrets = detect_exposed_secrets(body);
let aws = secrets.iter().find(|s| s.secret_type == "aws-access-token");
assert!(
aws.is_none(),
"EXAMPLE key should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_secret_detected_next_to_boolean_literal() {
let body = format!(r#"<script>var c={{apiKey:"{AWS_KEY}",debug:false}};</script>"#);
let secrets = detect_exposed_secrets(&body);
assert!(
secrets.iter().any(|s| s.secret_type == "aws-access-token"),
"AWS key next to `debug:false` must still be detected; got {secrets:?}"
);
}
#[test]
fn test_minified_page_allowlist_does_not_suppress_whole_body() {
let body = format!(
r#"<span data-cfemail="a1b2c3"></span>{}<script>var k="{AWS_KEY}";</script>"#,
" ".repeat(2000)
);
assert!(!body.contains('\n'), "test body must be newline-free");
let secrets = detect_exposed_secrets(&body);
assert!(
secrets.iter().any(|s| s.secret_type == "aws-access-token"),
"secret on a minified page with a distant allowlist token must be detected; got {secrets:?}"
);
}
#[test]
fn test_line_containing_capped_on_minified_body() {
let body = "x".repeat(5000);
let line = line_containing(&body, 2500, 2520);
assert!(
line.len() <= 2 * MAX_LINE_WINDOW_BYTES + 20,
"line window must be capped, got {} bytes",
line.len()
);
}
#[test]
fn test_detect_secret_in_response_header_block() {
let jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.\
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.\
dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
let header_block = format!("Content-Type: text/html\nSet-Cookie: session={jwt}; Path=/\n");
let secrets = detect_exposed_secrets_in_headers(&header_block);
assert!(
secrets.iter().any(|s| s.secret_type == "jwt"),
"JWT in Set-Cookie must be detected; got {secrets:?}"
);
assert!(
secrets.iter().all(|s| s.location == "set_cookie"),
"header findings must be tagged set_cookie"
);
}
#[test]
fn test_detect_aws_session_token() {
let body = "token=ASIA2BCDEF34567ZYXW";
let secrets = detect_exposed_secrets(body);
if secrets.len() == 1 {
assert_eq!(secrets[0].secret_type, "aws-access-token");
assert_eq!(secrets[0].severity, SecretSeverity::High);
}
}
#[test]
fn test_detect_google_api_key() {
let body = r#"var apiKey = "AIzaSyA1234567890abcdefghijklmnopqrstuv";"#;
let secrets = detect_exposed_secrets(body);
assert!(!secrets.is_empty());
assert!(secrets.iter().any(|s| s.secret_type == "gcp-api-key"));
}
#[test]
fn test_detect_google_api_key_in_url_with_trailing_param() {
let body = r#"<script src="https://maps.googleapis.com/maps/api/js?key=AIzaSyA1234567890abcdefghijklmnopqrstuv&libraries=places"></script>"#;
let secrets = detect_exposed_secrets(body);
let gcp = secrets.iter().find(|s| s.secret_type == "gcp-api-key");
assert!(
gcp.is_some(),
"GCP key followed by `&` in a URL must be detected; got {secrets:?}"
);
assert_eq!(
gcp.map(|s| s.matched_value.as_str()),
Some("AIzaSyA1234567890abcdefghijklmnopqrstuv"),
"capture must be the key alone, not include the delimiter"
);
}
#[test]
fn test_detect_openai_api_key() {
let a: String = (0..20)
.map(|i| (b'a' + u8::try_from(i % 26).unwrap()) as char)
.collect();
let b: String = (0..20)
.map(|i| (b'A' + u8::try_from(i % 26).unwrap()) as char)
.collect();
let body = format!(r#"key = "sk-{}T3BlbkFJ{}""#, a, b);
let secrets = detect_exposed_secrets(&body);
assert!(!secrets.is_empty());
assert!(secrets.iter().any(|s| s.secret_type == "openai-api-key"));
}
fn anthropic_key_mid() -> String {
(0..93)
.map(|i| {
let n = u8::try_from(i % 36).unwrap();
match n {
0..=9 => (b'0' + n) as char,
_ => (b'A' + (n - 10)) as char,
}
})
.collect()
}
#[test]
fn test_detect_anthropic_api_key() {
let key = format!("sk-ant-api03-{}AA", anthropic_key_mid());
let body = format!(r#"<script>const ANTHROPIC_API_KEY = "{key}";</script>"#);
let secrets = detect_exposed_secrets(&body);
let found = secrets
.iter()
.find(|s| s.secret_type == "anthropic-api-key")
.unwrap_or_else(|| panic!("expected anthropic-api-key; got {secrets:?}"));
assert_eq!(found.matched_value, key);
assert_eq!(found.severity, SecretSeverity::High);
}
#[test]
fn test_detect_anthropic_admin_api_key() {
let key = format!("sk-ant-admin01-{}AA", anthropic_key_mid());
let body = format!(r#"window.__cfg = {{ adminKey: "{key}" }};"#);
let secrets = detect_exposed_secrets(&body);
let found = secrets
.iter()
.find(|s| s.secret_type == "anthropic-admin-api-key")
.unwrap_or_else(|| panic!("expected anthropic-admin-api-key; got {secrets:?}"));
assert_eq!(found.matched_value, key);
assert_eq!(found.severity, SecretSeverity::High);
}
#[test]
fn test_detect_slack_bot_token() {
let body = r#"token: "xoxb-123456789012-1234567890123-ABCDEFabcdef123456789012""#;
let secrets = detect_exposed_secrets(body);
assert!(!secrets.is_empty());
assert!(secrets.iter().any(|s| s.secret_type == "slack-bot-token"));
}
#[test]
fn test_detect_rsa_private_key() {
let body = "-----BEGIN RSA PRIVATE KEY-----\n\
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC7VJTUt9Us8cKj\n\
MzEfYyjiWA4R4/M2bS1GB4t7NXp98C3SC6dVMvDuictGeurT8jNbvJZHtCSuYEvu\n\
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC7VJTUt9Us8cKj\n\
-----END RSA PRIVATE KEY-----";
let secrets = detect_exposed_secrets(body);
assert_eq!(secrets.len(), 1);
assert_eq!(secrets[0].secret_type, "private-key");
assert_eq!(secrets[0].severity, SecretSeverity::Critical);
}
#[test]
fn test_detect_vault_token() {
let suffix: String = (0..95)
.map(|i| (b'a' + u8::try_from(i % 26).unwrap()) as char)
.collect();
let body = format!(r#"VAULT_TOKEN="hvs.{}""#, suffix);
let secrets = detect_exposed_secrets(&body);
if !secrets.is_empty() {
assert!(secrets
.iter()
.any(|s| s.secret_type == "vault-service-token"
|| s.secret_type == "vault-batch-token"));
}
}
#[test]
fn test_shannon_entropy() {
assert!((shannon_entropy("") - 0.0).abs() < 1e-9);
assert!(shannon_entropy("aaaaaaaa") < shannon_entropy("abcd1234"));
}
#[test]
fn test_severity_for_rule_id_explicit_classifications() {
assert_eq!(
severity_for_rule_id("private-key"),
SecretSeverity::Critical
);
assert_eq!(
severity_for_rule_id("aws-access-token"),
SecretSeverity::High
);
assert_eq!(
severity_for_rule_id("gcp-api-key"),
SecretSeverity::Low,
"Maps/Firebase client keys are public-by-design"
);
assert_eq!(
severity_for_rule_id("generic-api-key"),
SecretSeverity::Medium,
"catch-all generic rule must not be High by default"
);
assert_eq!(
severity_for_rule_id("mapbox-api-token"),
SecretSeverity::Low
);
assert_eq!(
severity_for_rule_id("contentful-delivery-api-token"),
SecretSeverity::Low,
"Contentful Delivery tokens are public-by-design client keys"
);
assert_eq!(
severity_for_rule_id("algolia-api-key"),
SecretSeverity::Medium,
"Algolia admin stays Medium; search keys demote in severity_for_finding"
);
}
#[test]
fn test_severity_classifies_every_shipped_rule_id() {
let cfg = crate::parse::gitleaks::try_gitleaks().expect("config loads");
let explicit_high: std::collections::HashSet<&str> = [
"aws-access-token",
"http-basic-auth",
"mailchimp-api-key",
"openai-api-key",
"anthropic-api-key",
"anthropic-admin-api-key",
"sendgrid-api-token",
"twilio-api-key",
"npm-access-token",
"pypi-upload-token",
"digitalocean-access-token",
"digitalocean-pat",
"heroku-api-key",
"heroku-api-key-v2",
"flyio-access-token",
"shopify-access-token",
"shopify-private-app-access-token",
"shopify-shared-secret",
"bitbucket-client-secret",
"mailgun-private-api-token",
"cloudflare-api-key",
"doppler-api-token",
"plaid-secret-key",
"plaid-api-token",
"fastly-api-token",
]
.into_iter()
.collect();
for rule in &cfg.rules {
let sev = severity_for_rule_id(&rule.id);
assert_eq!(
sev,
severity_for_rule_id(&rule.id),
"non-deterministic for {}",
rule.id
);
if matches!(sev, SecretSeverity::High) {
let id = &rule.id;
let allowed_high = explicit_high.contains(id.as_str())
|| id.contains("private-key")
|| id.contains("password")
|| id.contains("client-secret")
|| id.contains("client_secret");
assert!(
allowed_high,
"rule '{id}' classified as High but not in the explicit map and \
doesn't contain a 'high-impact' substring; either add it to the \
explicit list or rethink the heuristic so it lands at Medium"
);
}
}
}
#[test]
fn test_severity_for_unknown_rule_id_heuristic() {
assert_eq!(
severity_for_rule_id("acme-private-key"),
SecretSeverity::High
);
assert_eq!(
severity_for_rule_id("foobar-password"),
SecretSeverity::High
);
assert_eq!(
severity_for_rule_id("zilch-client-secret"),
SecretSeverity::High
);
assert_eq!(
severity_for_rule_id("acme-access-token"),
SecretSeverity::Medium
);
assert_eq!(severity_for_rule_id("foo-api-key"), SecretSeverity::Medium);
assert_eq!(severity_for_rule_id("foo-pat"), SecretSeverity::Medium);
assert_eq!(
severity_for_rule_id("foo-credentials"),
SecretSeverity::Medium
);
assert_eq!(severity_for_rule_id("nonsense-rule"), SecretSeverity::Low);
assert_eq!(severity_for_rule_id("totally-random"), SecretSeverity::Low);
}
#[test]
fn test_location_inline_script() {
let body = format!(r#"<script>var key = "{}";</script>"#, AWS_KEY);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets[0].location, "inline_script");
}
#[test]
fn test_location_html_comment() {
let body = format!(r#"<!-- {} -->"#, AWS_KEY);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets[0].location, "html_comment");
}
#[test]
fn test_location_url_parameter() {
let body = r#"https://example.com?key=AIzaSyA1234567890abcdefghijklmnopqrstuv"#;
let secrets = detect_exposed_secrets(body);
assert!(!secrets.is_empty());
assert_eq!(secrets[0].location, "url_parameter");
}
#[test]
fn test_location_data_attribute() {
let body = format!(r#"<div data-api-key="{}">"#, AWS_KEY);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets[0].location, "data_attribute");
}
#[test]
fn test_location_default_html_body() {
let body = format!("just plain text {} in body", AWS_KEY);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets[0].location, "html_body");
}
#[test]
fn test_location_json_ld() {
let body = format!(
r#"<html><script type="application/ld+json">{{"apiKey":"{}"}}</script></html>"#,
AWS_KEY
);
let secrets = detect_exposed_secrets(&body);
assert!(
!secrets.is_empty(),
"expected secret in json-ld; got {secrets:?}"
);
assert_eq!(secrets[0].location, "json_ld");
}
#[test]
fn test_location_set_cookie_vs_other_header() {
let jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
let set_cookie = format!("Set-Cookie: session={jwt}; Path=/\n");
let sc = detect_exposed_secrets_in_headers(&set_cookie);
assert!(
sc.iter().any(|s| s.location == "set_cookie"),
"Set-Cookie must be set_cookie; got {sc:?}"
);
let auth = format!("Authorization: Bearer {jwt}\n");
let ah = detect_exposed_secrets_in_headers(&auth);
assert!(
ah.iter().any(|s| s.location == "response_header"),
"Authorization must stay response_header; got {ah:?}"
);
}
#[test]
fn test_detect_no_secrets() {
let body = "<html><body><p>Just regular HTML content</p></body></html>";
let secrets = detect_exposed_secrets(body);
assert!(secrets.is_empty());
}
#[test]
fn test_detect_deduplicates() {
let body = format!("first: {} second: {}", AWS_KEY, AWS_KEY);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets.len(), 1);
}
#[test]
fn test_full_value_stored_not_redacted() {
let body = AWS_KEY;
let secrets = detect_exposed_secrets(body);
assert_eq!(secrets[0].matched_value, AWS_KEY);
assert!(!secrets[0].matched_value.contains("***"));
}
#[test]
fn test_context_80_chars() {
let prefix = "A".repeat(100);
let suffix = "B".repeat(100);
let body = format!("{} {} {}", prefix, AWS_KEY, suffix);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets.len(), 1);
assert!(secrets[0].context.contains("AAAA"));
assert!(secrets[0].context.contains("BBBB"));
}
#[test]
fn test_context_cap_truncates_long_matches() {
let huge_key = format!(
"-----BEGIN RSA PRIVATE KEY-----\n{}\n-----END RSA PRIVATE KEY-----",
"MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC7".repeat(80)
);
let body = format!("// before\n{huge_key}\n// after");
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets.len(), 1);
let ctx = &secrets[0].context;
assert!(
ctx.len() <= MAX_CONTEXT_BYTES,
"context len {} must be <= MAX_CONTEXT_BYTES {}",
ctx.len(),
MAX_CONTEXT_BYTES
);
assert!(
ctx.contains("...[truncated]..."),
"context should mark truncation; got: {ctx:?}"
);
assert!(ctx.contains("BEGIN RSA PRIVATE KEY"));
assert!(ctx.contains("END RSA PRIVATE KEY"));
}
#[test]
fn test_context_cap_preserves_short_matches() {
let body = format!(r#"var key = "{AWS_KEY}";"#);
let secrets = detect_exposed_secrets(&body);
let aws = secrets
.iter()
.find(|s| s.secret_type == "aws-access-token")
.unwrap();
assert!(!aws.context.contains("...[truncated]..."));
assert!(aws.context.contains(AWS_KEY));
assert!(aws.context.len() < MAX_CONTEXT_BYTES);
}
#[test]
fn test_context_multibyte_boundary_no_panic() {
let prefix = format!("{}\u{0119}", "X".repeat(79)); assert_eq!(prefix.len(), 81);
assert!(!prefix.is_char_boundary(80));
let suffix = format!("\u{0119}{}", "Y".repeat(79));
let body = format!("{} {} {}", prefix, AWS_KEY, suffix);
let secrets = detect_exposed_secrets(&body);
assert_eq!(secrets.len(), 1, "should detect the AWS key");
assert!(secrets[0].context.contains("XXXX"));
assert!(secrets[0].context.contains("YYYY"));
}
#[test]
fn test_gitleaks_config_loads() {
let config = crate::parse::gitleaks::gitleaks();
assert!(config.rules.len() > 200, "expected 200+ gitleaks rules");
assert!(!config.global_allowlist.regexes.is_empty());
}
fn finding_keys(secrets: &[ExposedSecret]) -> std::collections::BTreeSet<(String, String)> {
secrets
.iter()
.map(|s| (s.secret_type.clone(), s.matched_value.clone()))
.collect()
}
#[test]
fn test_prefilter_equivalence_on_random_bodies() {
use proptest::prelude::*;
let _ = crate::parse::gitleaks::try_gitleaks().expect("gitleaks loads");
let body_strategy = prop_oneof![
"[\\x20-\\x7e]{0,2048}",
"[\\x20-\\xff]{0,1024}",
r#"var (key|token|api_key|apiKey) ?= ?"[A-Za-z0-9_-]{20,80}";"#,
r#"AKIA[A-Z2-7]{16}"#,
r#"AIzaSy[A-Za-z0-9_-]{33}"#,
r#"sk-[a-zA-Z0-9]{20}T3BlbkFJ[a-zA-Z0-9]{20}"#,
r#"[a-z][a-zA-Z]+\.[a-z]+=void"#,
];
proptest!(ProptestConfig::with_cases(256), |(body in body_strategy)| {
let with_prefilter = detect_exposed_secrets(&body);
let without_prefilter = detect_exposed_secrets_unfiltered(&body);
let with_keys = finding_keys(&with_prefilter);
let without_keys = finding_keys(&without_prefilter);
prop_assert_eq!(
with_keys.clone(),
without_keys.clone(),
"Prefilter divergence!\n\
body (first 200 chars): {}\n\
with_prefilter: {:?}\n\
without_prefilter: {:?}",
body.chars().take(200).collect::<String>(),
with_keys,
without_keys
);
});
}
#[test]
fn test_sourcegraph_no_fire_without_keyword() {
let sha_like = "9c02de5c56d82f105252bb92478c88114ab41dce";
let body = format!(r#"<span>commit {} </span>"#, sha_like);
let secrets = detect_exposed_secrets(&body);
let sourcegraph = secrets
.iter()
.find(|s| s.secret_type == "sourcegraph-access-token");
assert!(
sourcegraph.is_none(),
"sourcegraph-access-token must not fire without keyword in body; got {:?}",
secrets
);
}
#[test]
fn test_sourcegraph_fires_with_keyword() {
let token = format!(
"sgp_{}_{}",
"0123456789abcdef", "a1b2c3d4e5f6789012345678901234567890abcd"
);
let body = format!(r#"<script>window.SOURCEGRAPH = "{token}";</script>"#);
let secrets = detect_exposed_secrets(&body);
let sourcegraph = secrets
.iter()
.find(|s| s.secret_type == "sourcegraph-access-token");
assert!(
sourcegraph.is_some(),
"sourcegraph-access-token should fire for sgp_ tokens; got {secrets:?}"
);
assert_eq!(sourcegraph.unwrap().matched_value, token);
}
#[test]
fn test_sourcegraph_allowlist_html_id_skipped() {
let build_id = "1ccd1dddac2890afd4e9eb54f87f22008b1ed114";
let body = format!(
r#"<html id="{}" class="StudioLegacy Legacy">sourcegraph integration</html>"#,
build_id
);
let secrets = detect_exposed_secrets(&body);
let sourcegraph = secrets
.iter()
.find(|s| s.secret_type == "sourcegraph-access-token");
assert!(
sourcegraph.is_none(),
"40-char hex in html id= should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_sourcegraph_allowlist_cloudflare_email_skipped() {
let hex = "3f565159507f5e53545e52564b5a5c57115c5052";
let body = format!(
r#"<a href="/cdn-cgi/l/email-protection#{}">Contact</a> sourcegraph"#,
hex
);
let secrets = detect_exposed_secrets(&body);
let sourcegraph = secrets
.iter()
.find(|s| s.secret_type == "sourcegraph-access-token");
assert!(
sourcegraph.is_none(),
"40-char hex in Cloudflare email-protection# should be allowlisted; got {:?}",
secrets
);
let body2 = format!(
r#"<span class="__cf_email__" data-cfemail="{}">[email protected]</span> sourcegraph"#,
"cca5a2aaa38cada0a7ada1a5b8a9afa4e2afa3a1"
);
let secrets2 = detect_exposed_secrets(&body2);
let sg2 = secrets2
.iter()
.find(|s| s.secret_type == "sourcegraph-access-token");
assert!(
sg2.is_none(),
"40-char hex in data-cfemail= should be allowlisted; got {:?}",
secrets2
);
}
#[test]
fn test_hubspot_allowlist_form_id_skipped() {
let form_id = "AC4D982E-062E-4795-B5E5-718351F44BB9";
let body = format!(
r#"<div data-hubspot-form="{}" class="hs-form"></div>"#,
form_id
);
let secrets = detect_exposed_secrets(&body);
let hubspot = secrets.iter().find(|s| s.secret_type == "hubspot-api-key");
assert!(
hubspot.is_none(),
"data-hubspot-form= UUID should be allowlisted (form ID, not API key); got {:?}",
secrets
);
}
#[test]
fn test_hubspot_api_key_in_script_still_reported() {
let uuid = "AC4D982E-062E-4795-B5E5-718351F44BB9";
let body = format!(r#"<script>window.HUBSPOT_API_KEY="{}";</script>"#, uuid);
let secrets = detect_exposed_secrets(&body);
let hubspot = secrets.iter().find(|s| s.secret_type == "hubspot-api-key");
assert!(
hubspot.is_some(),
"hubspot UUID in script (no data-hubspot-form) should still be reported; got {:?}",
secrets
);
assert_eq!(hubspot.unwrap().matched_value, uuid);
assert!(
secrets
.iter()
.all(|s| s.secret_type != "generic-api-key" || s.matched_value != uuid),
"UUID-shaped values are not generic-api-key; HubSpot keeps its own rule; got {:?}",
secrets
);
}
#[test]
fn test_hubspot_correlation_id_header_skipped() {
let uuid = "019F9044-75EC-7F8C-9A70-F99ED4ECC4BD";
let headers = format!("x-hubspot-correlation-id: {uuid}\nserver: cloudflare\n");
let secrets = detect_exposed_secrets_in_headers(&headers);
let hubspot = secrets.iter().find(|s| s.secret_type == "hubspot-api-key");
assert!(
hubspot.is_none(),
"x-hubspot-correlation-id should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_hubspot_form_id_config_skipped() {
let form_id = "7EA134CD-6DBC-482C-B7C2-576FBF09725E";
let cases = [
format!(r#"PUBLIC_HUBSPOT_CONTACT_FORM_ID:"{form_id}""#),
format!(r#""hubspotFormIdProd":"{form_id}""#),
format!(r#"REACT_APP_HUBSPOT_FORM_ID_EN:"{form_id}""#),
format!(r#""hubspot_button_id":"{form_id}""#),
format!(r#"hubspotSignupguid:"{form_id}""#),
format!(r#"hubspotID:"{form_id}""#),
];
for body in cases {
let secrets = detect_exposed_secrets(&body);
let hubspot = secrets.iter().find(|s| s.secret_type == "hubspot-api-key");
assert!(
hubspot.is_none(),
"HubSpot form ID config should be allowlisted; body={body:?} got={secrets:?}"
);
}
}
#[test]
fn test_grafana_api_key_powerbi_embed_skipped() {
let token = "eyJrIjoiNTc5MmJjODMtYTM1NS00MWZlLWE1N2EtN2IyNThiOTk3MjI1IiwidCI6IjlkZjk0OWY4LWE2ZWItNDE5ZC05Y2FhLTFmOGM4M2RiNjc0ZiJ9";
let body = format!(r#"href="https://app.powerbi.com/view?r={token}" target="_blank""#);
let secrets = detect_exposed_secrets(&body);
let grafana = secrets.iter().find(|s| s.secret_type == "grafana-api-key");
assert!(
grafana.is_none(),
"Power BI embed token should not be grafana-api-key; got {:?}",
secrets
);
}
#[test]
fn test_grafana_api_key_without_powerbi_still_reported() {
let token = "eyJrIjoiNTc5MmJjODMtYTM1NS00MWZlLWE1N2EtN2IyNThiOTk3MjI1IiwidCI6IjlkZjk0OWY4LWE2ZWItNDE5ZC05Y2FhLTFmOGM4M2RiNjc0ZiJ9";
let body = format!(r#"const grafanaApiKey = "{token}";"#);
let secrets = detect_exposed_secrets(&body);
let grafana = secrets.iter().find(|s| s.secret_type == "grafana-api-key");
assert!(
grafana.is_some(),
"Grafana eyJrIjoi token without powerbi.com should still be reported; got {:?}",
secrets
);
assert_eq!(grafana.unwrap().matched_value, token);
}
#[test]
fn test_dropbox_short_identifier_near_dropbox_skipped() {
let body = r#"{"dropbox":true,"theChampSiteUrl":"abcde1234567890"}"#;
let secrets = detect_exposed_secrets(body);
let dropbox = secrets
.iter()
.find(|s| s.secret_type == "dropbox-api-token");
assert!(
dropbox.is_none(),
"15-char near dropbox must not fire dropbox-api-token; got {:?}",
secrets
);
}
#[test]
fn test_dropbox_long_and_short_lived_still_detected() {
let prefix11 = "abcdefghijk";
let mid = "AAAAAAAAAA";
let suffix43 = "0123456789_-x7km2pq9vl4nr8wy1st6ua3bc5de0fg";
assert_eq!(suffix43.len(), 43);
let long_tok = format!("{prefix11}{mid}{suffix43}");
let body_long = format!(r#"dropbox_token = "{long_tok}""#);
let secrets_long = detect_exposed_secrets(&body_long);
assert!(
secrets_long
.iter()
.any(|s| s.secret_type == "dropbox-long-lived-api-token"),
"long-lived Dropbox token must still match; got {secrets_long:?}"
);
let short_rest = "x7km2pq9vl4nr8wy1st6ua3bc5de0fg2hj4km6np8qs0tv2wx4yz6ab8cd0ef2gh4jx7km2pq9vl4nr8wy1st6ua3bc5de0fg2hj4km6np8qs0tv2wx4yz6ab8cd0ef2gh4jxxx";
assert_eq!(short_rest.len(), 135);
let short_tok = format!("sl.{short_rest}");
let body_short = format!(r#"dropbox_api = "{short_tok}""#);
let secrets_short = detect_exposed_secrets(&body_short);
assert!(
secrets_short
.iter()
.any(|s| s.secret_type == "dropbox-short-lived-api-token"),
"short-lived Dropbox token must still match; got {secrets_short:?}"
);
}
#[test]
fn test_square_eaaa_skipped_sq0atp_kept() {
let eaaa = "EAAA".to_string() + &"A".repeat(40);
let body_eaaa = format!(r#"binary blob {eaaa} noise"#);
let secrets_eaaa = detect_exposed_secrets(&body_eaaa);
assert!(
secrets_eaaa
.iter()
.all(|s| s.secret_type != "square-access-token"),
"EAAA must not match square-access-token; got {:?}",
secrets_eaaa
);
let sq = "sq0atp-9fK2mP7xQ4nR8wL1sT6uA3bC5dE0";
let body_sq = format!(r#"const token = "{sq}";"#);
let secrets_sq = detect_exposed_secrets(&body_sq);
let square = secrets_sq
.iter()
.find(|s| s.secret_type == "square-access-token");
assert!(
square.is_some(),
"sq0atp- Square PAT should still be reported; got {:?}",
secrets_sq
);
assert_eq!(square.unwrap().matched_value, sq);
}
#[test]
fn test_datadog_version_skipped_api_key_kept() {
let hash = "e561f43f1a2b3c4d5e6f708192a3b4c5d6e7f809";
let body_ver = format!(r#"{{"datadogVersion":"{hash}"}}"#);
let secrets_ver = detect_exposed_secrets(&body_ver);
assert!(
secrets_ver
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"datadogVersion hash must not match; got {:?}",
secrets_ver
);
let body_key = format!(r#"DD_API_KEY={hash}"#);
let secrets_key = detect_exposed_secrets(&body_key);
let dd = secrets_key
.iter()
.find(|s| s.secret_type == "datadog-access-token");
assert!(
dd.is_some(),
"DD_API_KEY assignment should still be reported; got {:?}",
secrets_key
);
assert_eq!(dd.unwrap().matched_value, hash);
}
#[test]
fn test_datadog_requires_datadog_context() {
let hash = "e561f43f1a2b3c4d5e6f708192a3b4c5d6e7f809";
let body_algolia_camel = format!(r#"var algoliaApiKey = "{hash}";"#);
let secrets_algolia_camel = detect_exposed_secrets(&body_algolia_camel);
assert!(
secrets_algolia_camel
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"algoliaApiKey assignment must not match datadog-access-token; got {:?}",
secrets_algolia_camel
);
let body_al_apikey = format!(r#"var al_apiKey = "{hash}";"#);
let secrets_al_apikey = detect_exposed_secrets(&body_al_apikey);
assert!(
secrets_al_apikey
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"al_apiKey assignment must not match datadog-access-token; got {:?}",
secrets_al_apikey
);
let body_nearby = format!(r#"algolia config: apiKey: "{hash}", appId: "ABC123XYZ""#);
let secrets_nearby = detect_exposed_secrets(&body_nearby);
assert!(
secrets_nearby
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"apiKey near 'algolia' context must not match datadog-access-token; got {:?}",
secrets_nearby
);
let body_bugsnag = format!(r#"Bugsnag.start({{ apiKey: "{hash}" }});"#);
let secrets_bugsnag = detect_exposed_secrets(&body_bugsnag);
assert!(
secrets_bugsnag
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"Bugsnag apiKey must not match datadog-access-token; got {:?}",
secrets_bugsnag
);
let body_bare = format!(r#"const apiKey = "{hash}";"#);
let secrets_bare = detect_exposed_secrets(&body_bare);
assert!(
secrets_bare
.iter()
.all(|s| s.secret_type != "datadog-access-token"),
"bare apiKey without Datadog context must not match; got {:?}",
secrets_bare
);
let body_key = format!(r#"DD_API_KEY={hash}"#);
let secrets_key = detect_exposed_secrets(&body_key);
let dd = secrets_key
.iter()
.find(|s| s.secret_type == "datadog-access-token");
assert!(
dd.is_some(),
"DD_API_KEY assignment should still be reported; got {:?}",
secrets_key
);
assert_eq!(dd.unwrap().matched_value, hash);
let body_rum = format!(
r#"window.DD_RUM.init({{ clientToken: "pubxxx", site: "datadoghq.com", apiKey: "{hash}" }});"#
);
let secrets_rum = detect_exposed_secrets(&body_rum);
assert!(
secrets_rum
.iter()
.any(|s| s.secret_type == "datadog-access-token" && s.matched_value == hash),
"apiKey near datadog RUM context should be reported; got {:?}",
secrets_rum
);
}
#[test]
fn test_facebook_page_token_requires_assignment() {
let token = format!(
"EAAC{}",
"x7Km2pQ9vL4nR8wY1sT6uA3bC5dE0fG2hJ4kM6nP8qS0tV2wX4yZ6aB8cD0eF2gH4j".repeat(2)
);
assert!(token.len() >= 104);
let body_bare = format!(r#"noise {token} more"#);
let secrets_bare = detect_exposed_secrets(&body_bare);
assert!(
secrets_bare
.iter()
.all(|s| s.secret_type != "facebook-page-access-token"),
"bare EAAC must not match facebook-page-access-token; got {:?}",
secrets_bare
);
let body_assign = format!(r#"access_token="{token}""#);
let secrets_assign = detect_exposed_secrets(&body_assign);
let fb = secrets_assign
.iter()
.find(|s| s.secret_type == "facebook-page-access-token");
assert!(
fb.is_some(),
"access_token= EAAC should still be reported; got {:?}",
secrets_assign
);
assert_eq!(fb.unwrap().matched_value, token);
}
#[test]
fn test_linkedin_camelcase_property_skipped() {
let body = r#"{"linkedin":"share","thumbnailWidth":"abcdefghijklmn"}"#;
let secrets = detect_exposed_secrets(body);
assert!(
secrets
.iter()
.all(|s| s.secret_type != "linkedin-client-id"),
"thumbnailWidth must not match linkedin-client-id; got {:?}",
secrets
);
}
#[test]
fn test_linkedin_client_secret_camelcase_skipped() {
let body = r#"linkedin_client_secret = "thumbnailWidthab""#;
let secrets = detect_exposed_secrets(body);
assert!(
secrets
.iter()
.all(|s| s.secret_type != "linkedin-client-secret"),
"camelCase property must not be reported as linkedin-client-secret; got {secrets:?}"
);
}
#[test]
fn test_linkedin_opaque_client_id_still_reported() {
let client_id = "ab12cd34ef56gh";
let body = format!(r#"linkedin_client_id = "{client_id}""#);
let secrets = detect_exposed_secrets(&body);
let linkedin = secrets
.iter()
.find(|s| s.secret_type == "linkedin-client-id");
assert!(
linkedin.is_some(),
"opaque linkedin client id should still be reported; got {:?}",
secrets
);
assert_eq!(linkedin.unwrap().matched_value, client_id);
}
#[test]
fn test_linkedin_opaque_client_secret_still_reported() {
let secret = "a1b2c3d4e5f6g7h8";
assert_eq!(secret.len(), 16);
let body = format!(r#"linkedin_client_secret = "{secret}""#);
let secrets = detect_exposed_secrets(&body);
let linkedin = secrets
.iter()
.find(|s| s.secret_type == "linkedin-client-secret");
assert!(
linkedin.is_some(),
"opaque linkedin client secret should still be reported; got {:?}",
secrets
);
assert_eq!(linkedin.unwrap().matched_value, secret);
}
#[test]
fn test_aws_amz_credential_severity_demoted() {
let akia = "AKIAYCQ2ABCD2EFGHJKL";
assert_eq!(akia.len(), 20);
let signed = format!(
r#"href="https://bucket.s3.amazonaws.com/x?X-Amz-Credential={akia}%2F20260101%2Fus-east-1%2Fs3%2Faws4_request""#
);
let secrets_signed = detect_exposed_secrets(&signed);
let aws_signed = secrets_signed
.iter()
.find(|s| s.secret_type == "aws-access-token");
assert!(
aws_signed.is_some(),
"Amz-Credential AKIA should still be recorded; got {:?}",
secrets_signed
);
assert_eq!(
aws_signed.unwrap().severity,
SecretSeverity::Low,
"Amz-Credential should be Low severity"
);
let comment = format!(r#"<!-- {akia} VFvFrZXsecretlooking -->"#);
let secrets_comment = detect_exposed_secrets(&comment);
let aws_comment = secrets_comment
.iter()
.find(|s| s.secret_type == "aws-access-token");
assert!(
aws_comment.is_some(),
"bare AKIA in comment should still be reported; got {:?}",
secrets_comment
);
assert_eq!(
aws_comment.unwrap().severity,
SecretSeverity::High,
"bare AKIA should remain High"
);
}
#[test]
fn test_generic_public_product_ids_skipped() {
let weglot_key = "wg_0123456789abcdef0123456789abcdef";
let body_wg = format!(r#"Weglot.initialize({{ api_key: '{weglot_key}' }});"#);
let secrets_wg = detect_exposed_secrets(&body_wg);
assert!(
secrets_wg
.iter()
.all(|s| !(s.secret_type == "generic-api-key"
&& s.matched_value.eq_ignore_ascii_case(weglot_key))),
"Weglot wg_ key should be allowlisted; got {:?}",
secrets_wg
);
let weglot_33 = "wg_0123456789abcdef0123456789abcdef0";
assert_eq!(weglot_33.len(), 36);
let body_wg33 = format!(r#"Weglot.initialize({{ api_key: '{weglot_33}' }});"#);
let secrets_wg33 = detect_exposed_secrets(&body_wg33);
assert!(
secrets_wg33
.iter()
.all(|s| !(s.secret_type == "generic-api-key"
&& s.matched_value.eq_ignore_ascii_case(weglot_33))),
"Weglot wg_ + 33 hex should be allowlisted; got {:?}",
secrets_wg33
);
let uuid = "12345678-1234-1234-1234-123456789abc";
let body_ai = format!(r#"instrumentationKey:'{uuid}'"#);
let secrets_ai = detect_exposed_secrets(&body_ai);
assert!(
secrets_ai
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == uuid)),
"App Insights instrumentationKey should be allowlisted; got {:?}",
secrets_ai
);
let body_prismic = format!(
r#"{{"link":{{"link_type":"Document","key":"{uuid}","url":"https://example.com"}}}}"#
);
let secrets_prismic = detect_exposed_secrets(&body_prismic);
assert!(
secrets_prismic
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == uuid)),
"Prismic link_type+key should be allowlisted; got {:?}",
secrets_prismic
);
let hex40 = "000f0192a841c56389c0ea2bff307ee1f771334f";
let body_minified_prismic =
format!(r#"last_publication_date:"2026-07-10",uid:aM,link_type:c,key:"{hex40}""#);
let secrets_minified = detect_exposed_secrets(&body_minified_prismic);
assert!(
secrets_minified
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex40)),
"minified link_type:c,key should be allowlisted; got {:?}",
secrets_minified
);
let body_react_key = format!(r#"return eb(ev,{{key:"{hex40}",role:this.getRole()}})"#);
let secrets_react = detect_exposed_secrets(&body_react_key);
assert!(
secrets_react
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex40)),
"React key:\"<40hex>\" should be allowlisted; got {:?}",
secrets_react
);
let body_bot = format!(r#""botSignalToken":"{hex40}","botSignalTimestamp":"6a89f8b7""#);
let secrets_bot = detect_exposed_secrets(&body_bot);
assert!(
secrets_bot
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex40)),
"botSignalToken should be allowlisted; got {:?}",
secrets_bot
);
let body_api = format!(r#"const apiKey = "{hex40}";"#);
let secrets_api = detect_exposed_secrets(&body_api);
assert!(
secrets_api
.iter()
.any(|s| s.secret_type == "generic-api-key" && s.matched_value == hex40),
"apiKey assignment should still match generic-api-key; got {:?}",
secrets_api
);
let doc_uuid = "01234567-89ab-cdef-0123-456789abcdef";
let body_cms = format!(r#"{{"id":"doc","key":"{doc_uuid}"}}"#);
let secrets_cms = detect_exposed_secrets(&body_cms);
assert!(
secrets_cms
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == doc_uuid)),
"CMS JSON key UUID must not be generic-api-key; got {secrets_cms:?}"
);
let body_api_uuid = format!(r#"const apiKey = "{doc_uuid}";"#);
let secrets_api_uuid = detect_exposed_secrets(&body_api_uuid);
assert!(
secrets_api_uuid
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == doc_uuid)),
"UUID-shaped values are not generic-api-key even on apiKey=; got {secrets_api_uuid:?}"
);
}
#[test]
fn test_looks_like_hyphenated_uuid() {
assert!(looks_like_hyphenated_uuid(
"01234567-89ab-cdef-0123-456789abcdef"
));
assert!(looks_like_hyphenated_uuid(
"AC4D982E-062E-4795-B5E5-718351F44BB9"
));
assert!(!looks_like_hyphenated_uuid(
"a7f3c9e2b81d4056f9e4a1c8b7d60352e1f90a4b"
));
assert!(!looks_like_hyphenated_uuid("not-a-uuid"));
}
#[test]
fn test_discord_client_secret_requires_assignment() {
let body_fp = r#"{"platforms-subtitle1-image2":"https://assets.example.com/ai-live-captions-google-meet-discord-voov.webp","platforms-subtitle1-image2-title":"Online meeting"}"#;
let secrets_fp = detect_exposed_secrets(body_fp);
assert!(
secrets_fp
.iter()
.all(|s| s.secret_type != "discord-client-secret"),
"discord in URL/CSS must not fire discord-client-secret; got {:?}",
secrets_fp
);
let secret = "a1b2c3d4e5f6789012345678abcdef01";
let body_ok = format!(r#"discord_client_secret = "{secret}""#);
let secrets_ok = detect_exposed_secrets(&body_ok);
let hit = secrets_ok
.iter()
.find(|s| s.secret_type == "discord-client-secret");
assert!(
hit.is_some(),
"discord_client_secret assignment should be reported; got {:?}",
secrets_ok
);
assert_eq!(hit.unwrap().matched_value, secret);
}
#[test]
fn test_generic_cdn_embed_product_ids_skipped() {
let hex64 = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
assert_eq!(hex64.len(), 64);
let body_boss = format!(
r#"<img src="https://img.ibosscdn.com/assets/hero.jpg?bossToken={hex64}&w=800">"#
);
let secrets_boss = detect_exposed_secrets(&body_boss);
assert!(
secrets_boss
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex64)),
"ImageBoss bossToken should be allowlisted; got {:?}",
secrets_boss
);
let hex32 = "0123456789abcdef0123456789abcdef";
assert_eq!(hex32.len(), 32);
let body_yt = format!(
r#"<img src="https://i.ytimg.com/vi/abcdefghijk/hqdefault.jpg?sqp=-o&key={hex32}">"#
);
let secrets_yt = detect_exposed_secrets(&body_yt);
assert!(
secrets_yt
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex32)),
"ytimg.com embed key= should be allowlisted; got {:?}",
secrets_yt
);
let body_vimeo = format!(
r#"<iframe src="https://player.vimeo.com/video/123456789?key={hex32}"></iframe>"#
);
let secrets_vimeo = detect_exposed_secrets(&body_vimeo);
assert!(
secrets_vimeo
.iter()
.all(|s| !(s.secret_type == "generic-api-key" && s.matched_value == hex32)),
"vimeo.com embed key= should be allowlisted; got {:?}",
secrets_vimeo
);
let body_first_party = format!(r#"fetch("https://example.com/api?api_key={hex32}")"#);
let secrets_fp = detect_exposed_secrets(&body_first_party);
assert!(
secrets_fp
.iter()
.any(|s| s.secret_type == "generic-api-key" && s.matched_value == hex32),
"first-party api_key= must still match generic-api-key; got {:?}",
secrets_fp
);
}
#[test]
fn test_algolia_search_demoted_admin_stays_medium() {
let key = "a1b2c3d4e5f6789012345678abcdef01";
assert_eq!(key.len(), 32);
let body_search =
format!(r#"const cfg = {{ algoliaApiKey: "{key}", algoliaAppId: "ABC123XYZ0" }};"#);
let secrets_search = detect_exposed_secrets(&body_search);
let search = secrets_search
.iter()
.find(|s| s.secret_type == "algolia-api-key");
assert!(
search.is_some(),
"Algolia search key should still be recorded; got {:?}",
secrets_search
);
assert_eq!(
search.unwrap().severity,
SecretSeverity::Low,
"Algolia search key should be Low inventory"
);
let body_admin = format!(r#"const ALGOLIA_ADMIN_KEY = "{key}";"#);
let secrets_admin = detect_exposed_secrets(&body_admin);
let admin = secrets_admin
.iter()
.find(|s| s.secret_type == "algolia-api-key");
assert!(
admin.is_some(),
"Algolia admin key should be recorded; got {:?}",
secrets_admin
);
assert_eq!(
admin.unwrap().severity,
SecretSeverity::Medium,
"Algolia admin assignment must stay Medium"
);
let body_both =
format!(r#"ALGOLIA_APPLICATION_ID="ABC123XYZ0"; ALGOLIA_ADMIN_KEY="{key}";"#);
let secrets_both = detect_exposed_secrets(&body_both);
let both = secrets_both
.iter()
.find(|s| s.secret_type == "algolia-api-key");
assert!(
both.is_some(),
"Algolia admin+appId should still be recorded; got {:?}",
secrets_both
);
assert_eq!(
both.unwrap().severity,
SecretSeverity::Medium,
"Algolia admin next to App ID must stay Medium"
);
}
#[test]
fn test_contentful_delivery_token_is_low() {
let token = "9f3k2m8q1p7n4t6w0x5z8b2c7d1h4j9l3s6v0y2a8fq";
assert_eq!(token.len(), 43);
let body = format!(r#"contentfulAccessToken="{token}""#);
let secrets = detect_exposed_secrets(&body);
let cda = secrets
.iter()
.find(|s| s.secret_type == "contentful-delivery-api-token");
assert!(
cda.is_some(),
"Contentful delivery token should be recorded; got {:?}",
secrets
);
assert_eq!(
cda.unwrap().severity,
SecretSeverity::Low,
"Contentful CDA should be Low inventory"
);
}
#[test]
fn test_jwt_severity_is_low() {
assert_eq!(severity_for_rule_id("jwt"), SecretSeverity::Low);
assert_eq!(severity_for_rule_id("jwt-base64"), SecretSeverity::Low);
}
#[test]
fn test_linkedin_client_id_allowlist_structure_skipped() {
let body = r#"{"blockId":"uselectrical.b2bstore@4.x:menu-item#footer-linkedin","extensionPointId":"menu-item#footer-linkedin"}"#;
let secrets = detect_exposed_secrets(body);
let linkedin = secrets
.iter()
.find(|s| s.secret_type == "linkedin-client-id");
assert!(
linkedin.is_none(),
"linkedin-client-id with extensionPointId/footer-linkedin should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_sumologic_allowlist_site_id_skipped() {
let site_id = "38d92200f6b3d700b2eb2e0069250000108b3e00a638e0004c77b700ec8ea400";
let body = format!(
r#"j.dataset.sumoSiteId='{}';j.dataset.sumoPlatform='wordpress';"#,
site_id
);
let secrets = detect_exposed_secrets(&body);
let sumo = secrets
.iter()
.find(|s| s.secret_type == "sumologic-access-token");
assert!(
sumo.is_none(),
"sumologic sumoSiteId (public site ID) should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_path_restricted_rule_skipped_on_html() {
let body = r#"<script>p_lt_ctl13_AFI_CustomRegistrationForm_plcUp_formUser_UserPassword_rfvConfirmPassword.validationGroup = "ConfirmRegForm";</script>"#;
let secrets = detect_exposed_secrets(body);
let tf_password = secrets
.iter()
.find(|s| s.secret_type == "hashicorp-tf-password");
assert!(
tf_password.is_none(),
"hashicorp-tf-password (path-restricted) must be skipped when scanning HTML; got {:?}",
secrets
);
}
#[test]
fn test_sonar_secret_group_2() {
let token = "squ_abcdefghij0123456789abcdefghij012345"; let body = format!(r#"sonar_token="{}""#, token);
let secrets = detect_exposed_secrets(&body);
let sonar = secrets.iter().find(|s| s.secret_type == "sonar-api-token");
assert!(
sonar.is_some(),
"expected sonar-api-token finding: {:?}",
secrets
);
assert_eq!(
sonar.unwrap().matched_value,
token,
"secretGroup=2 should yield the token (group 2), not 'token' (group 1)"
);
}
#[test]
fn test_rule_allowlist_condition_and_with_paths_does_not_skip() {
use crate::parse::gitleaks::CompiledRuleAllowlist;
use regex::Regex;
let re = Regex::new("EXAMPLE").unwrap();
let list = CompiledRuleAllowlist {
regexes: vec![re],
stopwords: vec![],
regex_target: None,
condition_and: true,
has_paths: true,
};
let skips = rule_allowlist_skips(
&[list],
"AKIAIOSFODNN7EXAMPLE",
"line content",
"full match",
);
assert!(
!skips,
"AND with has_paths must not skip (path never matches in single-blob)"
);
}
#[test]
fn test_detect_mongodb_connection_uri() {
let body = r#"<script>var dbUrl = "mongodb+srv://admin:s3cretP4ss@cluster0.mongodb.net/mydb";</script>"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(db.is_some(), "should detect MongoDB URI; got {:?}", secrets);
let db = db.unwrap();
assert_eq!(
db.matched_value,
"mongodb+srv://admin:s3cretP4ss@cluster0.mongodb.net/mydb"
);
assert_eq!(db.severity, SecretSeverity::Critical);
}
#[test]
fn test_detect_postgres_connection_uri() {
let body = r#"<!-- config: postgres://appuser:hunter2@db.example.com:5432/production -->"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_some(),
"should detect PostgreSQL URI; got {:?}",
secrets
);
assert_eq!(
db.unwrap().matched_value,
"postgres://appuser:hunter2@db.example.com:5432/production"
);
}
#[test]
fn test_detect_redis_connection_uri() {
let body = r#"REDIS_URL=redis://default:myP4ssword@cache.example.com:6379/0"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(db.is_some(), "should detect Redis URI; got {:?}", secrets);
assert_eq!(
db.unwrap().matched_value,
"redis://default:myP4ssword@cache.example.com:6379/0"
);
}
#[test]
fn test_detect_mysql_connection_uri() {
let body = r#"mysql://root:Str0ngP@ss@mysql.internal:3306/appdb"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(db.is_some(), "should detect MySQL URI; got {:?}", secrets);
}
#[test]
fn test_no_detect_mongodb_without_credentials() {
let body = r#"mongodb://localhost/testdb"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_none(),
"should NOT detect URI without credentials; got {:?}",
secrets
);
}
#[test]
fn test_detect_http_basic_auth() {
let body = r#"<script>xhr.setRequestHeader("Authorization", "Basic dXNlcjpzM2NyZXRQNHNz");</script>"#;
let secrets = detect_exposed_secrets(body);
let auth = secrets.iter().find(|s| s.secret_type == "http-basic-auth");
assert!(
auth.is_some(),
"should detect HTTP Basic Auth; got {:?}",
secrets
);
assert_eq!(auth.unwrap().severity, SecretSeverity::High);
}
#[test]
fn test_no_detect_http_basic_auth_too_short() {
let body = r#"Authorization: Basic Og=="#;
let secrets = detect_exposed_secrets(body);
let auth = secrets.iter().find(|s| s.secret_type == "http-basic-auth");
assert!(
auth.is_none(),
"trivially short Basic auth should not match; got {:?}",
secrets
);
}
#[test]
fn test_detect_credential_url() {
let body =
r#"fetch("https://deploy:ghp_x7K9mQ2vL8nR3pW1234567890ab@api.internal.com/v1/data")"#;
let secrets = detect_exposed_secrets(body);
let url = secrets
.iter()
.find(|s| s.secret_type == "credential-bearing-url");
assert!(
url.is_some(),
"should detect credential URL; got {:?}",
secrets
);
assert_eq!(url.unwrap().severity, SecretSeverity::Critical);
}
#[test]
fn test_detect_mailchimp_api_key() {
let key = format!("{}-us14", "abcdef1234567890abcdef1234567890");
let body = format!(r#"<script>var mc_key = "mailchimp {key}";</script>"#);
let secrets = detect_exposed_secrets(&body);
let mc = secrets
.iter()
.find(|s| s.secret_type == "mailchimp-api-key");
assert!(
mc.is_some(),
"should detect Mailchimp API key; got {:?}",
secrets
);
assert_eq!(mc.unwrap().severity, SecretSeverity::High);
}
#[test]
fn test_detect_sendgrid_api_key() {
let key = format!(
"SG.{}.{}",
"ngeVfQFYQlKU0ufo8x5d1A", "TwL2iGABf9DHoTf09kqeF8tAmbihYzrnopKc1s5cr3t"
);
let body = format!(r#"apiKey: "{key}""#);
let secrets = detect_exposed_secrets(&body);
let sg = secrets
.iter()
.find(|s| s.secret_type == "sendgrid-api-token");
assert!(
sg.is_some(),
"should detect SendGrid API key; got {:?}",
secrets
);
}
#[test]
fn test_no_detect_placeholder_password_in_db_uri() {
let body = r#"mongodb://admin:$PASSWORD@cluster.mongodb.net/db"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_none(),
"variable placeholder $PASSWORD should not be flagged; got {:?}",
secrets
);
}
#[test]
fn test_no_detect_placeholder_xxx_in_db_uri() {
let body = r#"postgres://user:xxxxxxxx@db.example.com/app"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_none(),
"redacted xxxxxxxx should not be flagged; got {:?}",
secrets
);
}
#[test]
fn test_no_detect_placeholder_template_token_in_db_uri() {
let body = r#"<script>db = "mongodb://admin:<password>@cluster.local/db";</script>"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_none(),
"<password> template token should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_no_detect_placeholder_literal_password_in_db_uri() {
let body = r#"redis://default:password@cache.example.com:6379/0"#;
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "database-connection-uri");
assert!(
db.is_none(),
"literal 'password' value should be allowlisted; got {:?}",
secrets
);
}
#[test]
fn test_no_detect_placeholder_in_jdbc_connection_string() {
let body = "jdbc:mysql://localhost/db?user=admin&password=<password>";
let secrets = detect_exposed_secrets(body);
let db = secrets
.iter()
.find(|s| s.secret_type == "jdbc-connection-string");
assert!(
db.is_none(),
"<password> in JDBC string should be allowlisted; got {:?}",
secrets
);
}
}