use regex::Regex;
use std::borrow::Cow;
use std::sync::OnceLock;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
pub enum Severity {
Critical,
High,
Medium,
}
impl Severity {
pub fn as_str(self) -> &'static str {
match self {
Severity::Critical => "critical",
Severity::High => "high",
Severity::Medium => "medium",
}
}
}
impl std::fmt::Display for Severity {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone)]
pub struct Rule {
pub(crate) name: Cow<'static, str>,
pub(crate) severity: Severity,
pub(crate) regex: Regex,
pub(crate) validator: Option<fn(&str) -> Option<bool>>,
}
impl Rule {
pub fn name(&self) -> &str {
&self.name
}
pub fn severity(&self) -> Severity {
self.severity
}
pub fn pattern(&self) -> &str {
self.regex.as_str()
}
}
#[rustfmt::skip]
const RULES: &[(&str, Severity, &str)] = &[
("AWS Access Key", Severity::Critical, r"AKIA[0-9A-Z]{16}"),
("AWS Secret Key", Severity::Critical, r#"(?i)aws[_-]?secret[_-]?access[_-]?key["'\s:=]+[A-Za-z0-9/+=]{40}"#),
("Google API Key", Severity::Critical, r"AIza[0-9A-Za-z\-_]{35}"),
("Google OAuth Access Token", Severity::Critical, r"ya29\.[A-Za-z0-9_.-]{20,}"),
("GCP Service Account", Severity::Critical, r#""type"\s*:\s*"service_account""#),
("Firebase FCM Server Key", Severity::Critical, r"AAAA[A-Za-z0-9_-]{7}:APA91b[A-Za-z0-9_-]{100,}"),
("Azure Storage Account Key", Severity::Critical, r"(?i)AccountKey=[A-Za-z0-9+/]{86}=="),
("Azure SAS Token", Severity::High, r#"sv=\d{4}-\d{2}-\d{2}[^\s"']*?&sig=[A-Za-z0-9%+/=]{20,}"#),
("Azure AD Client Secret", Severity::High, r"[A-Za-z0-9_~.]{3}[78]Q~[A-Za-z0-9_~.-]{31,34}"),
("DigitalOcean Token", Severity::Critical, r"do[opr]_v1_[0-9a-f]{64}"),
("Heroku API Key", Severity::High, r#"(?i)heroku[a-z0-9_ "':=-]{0,20}\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b"#),
("Fly.io Token", Severity::Critical, r"fo1_[A-Za-z0-9+/=_-]{40,}"),
("Vercel Token", Severity::High, r#"(?i)vercel[a-z0-9_ "':=-]{0,20}\b[a-z0-9]{24}\b"#),
("Netlify PAT", Severity::Critical, r"nfp_[A-Za-z0-9_-]{36,}"),
("Cloudflare API Token", Severity::High, r#"(?i)cloudflare[a-z0-9_ "':=-]{0,20}\b[A-Za-z0-9_-]{40}\b"#),
("GitHub Token", Severity::Critical, r"gh[pousr]_[A-Za-z0-9]{36,255}"),
("GitHub Fine-Grained PAT", Severity::Critical, r"github_pat_[A-Za-z0-9_]{82}"),
("GitLab PAT", Severity::Critical, r"glpat-[A-Za-z0-9\-_]{20,}"),
("npm Token", Severity::Critical, r"npm_[A-Za-z0-9]{36}"),
("Docker Hub PAT", Severity::Critical, r"dckr_pat_[A-Za-z0-9_-]{27,}"),
("PyPI API Token", Severity::Critical, r"pypi-AgEIcHlwaS5vcmc[A-Za-z0-9_-]{50,}"),
("crates.io Token", Severity::High, r"\bcio[A-Za-z0-9]{29,}"),
("RubyGems API Key", Severity::Critical, r"rubygems_[0-9a-f]{48}"),
("HashiCorp Vault Token", Severity::Critical, r"\bhv[sb]\.[A-Za-z0-9_-]{24,}"),
("Stripe Live Secret", Severity::Critical, r"sk_live_[0-9a-zA-Z]{24,}"),
("Stripe Test Secret", Severity::High, r"sk_test_[0-9a-zA-Z]{24,}"),
("Square Access Token", Severity::Critical, r"sq0atp-[A-Za-z0-9_-]{22}"),
("Square OAuth Secret", Severity::Critical, r"sq0csp-[A-Za-z0-9_-]{43}"),
("Braintree Access Token", Severity::Critical, r"access_token\$production\$[0-9a-z]{16}\$[0-9a-f]{32}"),
("Shopify Token", Severity::Critical, r"shp(?:at|ca|pa|ss)_[0-9a-fA-F]{32}"),
("Slack Token", Severity::Critical, r"xox[baprs]-[A-Za-z0-9-]{10,}"),
("Slack Webhook", Severity::High, r"https://hooks\.slack\.com/services/T[A-Z0-9]+/B[A-Z0-9]+/[A-Za-z0-9]{24}"),
("Discord Bot Token", Severity::Critical, r"[MN][A-Za-z\d]{23}\.[\w-]{6}\.[\w-]{27,}"),
("Discord Webhook URL", Severity::High, r"https://(?:canary\.|ptb\.)?discord(?:app)?\.com/api/webhooks/\d+/[A-Za-z0-9\-_]+"),
("Telegram Bot Token", Severity::Critical, r"\b\d{8,10}:A[A-Za-z0-9_-]{34}"),
("OpenAI API Key", Severity::Critical, r"sk-(?:proj-)?[A-Za-z0-9_-]{40,}"),
("Anthropic API Key", Severity::Critical, r"sk-ant-[a-z0-9]+-[A-Za-z0-9_-]{32,}"),
("Hugging Face Token", Severity::Critical, r"\bhf_[A-Za-z0-9]{34}\b"),
("Groq API Key", Severity::Critical, r"gsk_[A-Za-z0-9]{52}"),
("Twilio API Key", Severity::Critical, r"SK[0-9a-fA-F]{32}"),
("SendGrid API Key", Severity::Critical, r"SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}"),
("Mailgun API Key", Severity::High, r"key-[0-9a-f]{32}"),
("Mailchimp API Key", Severity::Critical, r"\b[0-9a-f]{32}-us\d{1,2}\b"),
("Age Secret Key", Severity::Critical, r"AGE-SECRET-KEY-1[A-Z0-9]{58}"),
("Private Key Block", Severity::Critical, r"-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED |PGP )?PRIVATE KEY-----"),
("JWT", Severity::Medium, r"eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"),
("Database URL with password", Severity::High, r"(?:postgres|postgresql|mysql|mongodb|redis|amqp)://[^:\s]+:[^@\s]+@[^/\s]+"),
("HTTP Basic Auth Header", Severity::High, r"(?i)authorization:\s*basic\s+[A-Za-z0-9+/]{16,}={0,2}"),
("pgpass Line", Severity::Medium, r"(?m)^[^:\s]{1,64}:[0-9]{1,5}:[^:\n]{1,64}:[^:\n]{1,64}:[^:\s]{4,}$"),
("Kubernetes Client Key", Severity::Medium, r"client-key-data:\s*[A-Za-z0-9+/=]{40,}"),
];
pub fn builtin_rules() -> &'static [Rule] {
static SLOT: OnceLock<Vec<Rule>> = OnceLock::new();
SLOT.get_or_init(build_rules).as_slice()
}
fn build_rules() -> Vec<Rule> {
RULES
.iter()
.map(|&(name, severity, pattern)| Rule {
name: Cow::Borrowed(name),
severity,
regex: Regex::new(pattern).expect("invalid built-in secret rule regex"),
validator: match name {
"GitHub Token" => Some(github_token_checksum),
_ => None,
},
})
.collect()
}
fn github_token_checksum(token: &str) -> Option<bool> {
let payload = token
.strip_prefix("gh")?
.strip_prefix(['p', 'o', 'u', 's', 'r'])?
.strip_prefix('_')?;
if payload.len() != 36 || !payload.is_ascii() {
return None;
}
let (random, checksum) = payload.split_at(30);
Some(base62_6(crc32(random.as_bytes())) == checksum.as_bytes())
}
fn crc32(data: &[u8]) -> u32 {
let mut crc = 0xFFFF_FFFFu32;
for &byte in data {
crc ^= u32::from(byte);
for _ in 0..8 {
let mask = (crc & 1).wrapping_neg();
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
}
}
!crc
}
fn base62_6(mut n: u32) -> [u8; 6] {
const ALPHABET: &[u8; 62] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
let mut out = [b'0'; 6];
for slot in out.iter_mut().rev() {
*slot = ALPHABET[(n % 62) as usize];
n /= 62;
if n == 0 {
break;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_rule_compiles_and_names_are_unique() {
let rules = builtin_rules();
assert_eq!(rules.len(), RULES.len());
let mut names: Vec<&str> = rules.iter().map(Rule::name).collect();
names.sort_unstable();
names.dedup();
assert_eq!(names.len(), rules.len(), "duplicate rule name");
}
#[test]
fn doc_table_lists_every_rule() {
let source = include_str!("rules.rs");
let rows = source.lines().filter(|l| l.trim_start().starts_with("//! |")).count();
assert_eq!(rows - 2, RULES.len(), "rules table in module docs is out of sync");
}
#[test]
fn severity_strings_match_klappstuhl_dashboard_values() {
assert_eq!(Severity::Critical.as_str(), "critical");
assert_eq!(Severity::High.as_str(), "high");
assert_eq!(Severity::Medium.as_str(), "medium");
}
#[test]
fn github_checksum_round_trip() {
let random = "16C7e42F292c6912E7710c838347Ae"; let checksum = base62_6(crc32(random.as_bytes()));
let token = format!("ghp_{random}{}", std::str::from_utf8(&checksum).unwrap());
assert_eq!(github_token_checksum(&token), Some(true));
let tampered = token.replace("16C7", "16C8");
assert_eq!(github_token_checksum(&tampered), Some(false));
assert_eq!(github_token_checksum(&format!("ghp_{}", "a".repeat(40))), None);
}
#[test]
fn crc32_matches_the_ieee_reference_vector() {
assert_eq!(crc32(b"123456789"), 0xCBF4_3926);
}
}