use super::*;
use crate::schema::MemoryType;
fn noise(len: usize, seed: u64) -> String {
const ALPHABET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
let mut state = seed
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
let mut out: Vec<u8> = (0..len)
.map(|_| {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
ALPHABET[(state % ALPHABET.len() as u64) as usize]
})
.collect();
out[0] = b'Q';
out[1] = b'q';
out[2] = b'7';
String::from_utf8(out).unwrap()
}
fn pem(label: &str, terminated: bool) -> String {
let dashes = "-".repeat(5);
let body = (0..6)
.map(|i| noise(64, 100 + i))
.collect::<Vec<_>>()
.join("\n");
let mut block = format!("{dashes}BEGIN {label} {}{dashes}\n{body}\n", "PRIVATE KEY");
if terminated {
block.push_str(&format!("{dashes}END {label} {}{dashes}", "PRIVATE KEY"));
}
block
}
fn positives() -> Vec<(String, String, SecretKind)> {
let gh = |prefix: &str, seed| [prefix, "_"].concat() + &noise(36, seed);
let ghp = gh(&["gh", "p"].concat(), 1);
let gho = gh(&["gh", "o"].concat(), 2);
let ghs = gh(&["gh", "s"].concat(), 3);
let ghu = gh(&["gh", "u"].concat(), 4);
let pat = ["github", "_pat_"].concat() + &noise(82, 5);
let sk_proj = ["s", "k-proj-"].concat() + &noise(48, 6);
let sk_ant = ["s", "k-ant-api03-"].concat() + &noise(93, 7) + "-AA";
let sk_legacy = ["s", "k-"].concat() + &noise(48, 8);
let slack = ["xo", "xb-"].concat() + "123456789012-1234567890123-" + &noise(24, 9);
let webhook = ["https://hooks.", "slack.com/services/"].concat()
+ "T0123ABCD/B0456EFGH/"
+ &noise(24, 10);
let google = ["AI", "za"].concat() + &noise(35, 11);
let jwt = format!(
"{}{}.{}{}.{}",
["ey", "J"].concat(),
noise(30, 12),
["ey", "J"].concat(),
noise(60, 13),
noise(43, 14)
);
let bearer = noise(40, 15);
let basic = noise(24, 16);
let url_pass = "S3cretPw".to_string() + &noise(6, 17);
let assigned = noise(20, 18);
let aws_secret = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string();
let openssh = pem("OPENSSH", true);
let rsa_cut = pem("RSA", false);
let hex_key = ["s", "k-"].concat() + &"3f9a1c7e5b2d8046".repeat(2);
let redis_pass = ["p4ss", "w0rdXy"].concat();
let stripe = ["s", "k_live_"].concat() + &noise(24, 21);
let at_pass = ["Pa", "ss@"].concat() + &noise(10, 22);
let pgp_body = noise(64, 19);
let pgp_cut = format!(
"{d}BEGIN PGP {}{d}\nVersion: GnuPG v2\n\n{pgp_body}\n{}",
"PRIVATE KEY BLOCK",
noise(64, 20),
d = "-".repeat(5)
);
let header_key = noise(32, 23);
let escaped_sk = ["s", "k-proj-"].concat() + &noise(48, 24);
let escaped_google = ["AI", "za"].concat() + &noise(35, 25);
let escaped_jwt = format!(
"{}{}.{}{}.{}",
["ey", "J"].concat(),
noise(30, 26),
["ey", "J"].concat(),
noise(60, 27),
noise(43, 28)
);
let slash_secret = format!("/{}", noise(39, 29));
let sendgrid = format!(
"{}.{}.{}",
["S", "G"].concat(),
noise(22, 33),
noise(43, 34)
);
let typed = noise(24, 35);
let openrouter = ["s", "k-or-v1-"].concat() + &"a3f9c1e7b5d20846".repeat(4);
let escaped_pass = format!("{}\\!{}", noise(6, 36), noise(8, 37));
let amp_short = format!("{}&{}", noise(3, 41), noise(10, 42));
let amp_long = format!("{}&{}", noise(9, 43), noise(8, 44));
vec![
(
format!("DB_PASSWORD={amp_short}"),
amp_short.clone(),
SecretKind::Secret,
),
(
format!("POSTGRES_PASSWORD: {amp_short}"),
amp_short,
SecretKind::Secret,
),
(format!("password={amp_long}"), amp_long, SecretKind::Secret),
(
format!("def connect(password: str=\"{typed}\"):"),
typed.clone(),
SecretKind::Secret,
),
(
format!("password:str=\"{typed}\""),
typed.clone(),
SecretKind::Secret,
),
(
format!("const password: string=\"{typed}\";"),
typed.clone(),
SecretKind::Secret,
),
(
format!(
"curl \"https://api.example.com/v1/hook?token={typed}&url=https://example.com/cb\""
),
typed.clone(),
SecretKind::Secret,
),
(
format!(
"GET /oauth/callback?access_token={typed}&redirect_uri=https://app.example.com/cb"
),
typed.clone(),
SecretKind::Secret,
),
(
format!("GET /v1/keys?api_key_id=42&api_key={typed}"),
typed.clone(),
SecretKind::Secret,
),
(
format!("const secretKey = \"{typed}\";"),
typed.clone(),
SecretKind::Secret,
),
(
format!("secretKey: {typed}"),
typed.clone(),
SecretKind::Secret,
),
(
format!("jwtSecretKey={typed}"),
typed.clone(),
SecretKind::Secret,
),
(
format!("SECRETKEY={typed}"),
typed.clone(),
SecretKind::Secret,
),
(
format!("export DB_PASSWORD={escaped_pass}"),
escaped_pass.clone(),
SecretKind::Secret,
),
(
format!("password = \"{escaped_pass}\""),
escaped_pass,
SecretKind::Secret,
),
(
format!("your key {openrouter} is invalid"),
openrouter,
SecretKind::ApiKey,
),
(
format!("DB_PASSWORD_PROD={typed}"),
typed.clone(),
SecretKind::Secret,
),
(
format!("const apiKey: string = \"{typed}\";"),
typed.clone(),
SecretKind::Secret,
),
(
format!("API_KEY: str = \"{typed}\""),
typed.clone(),
SecretKind::Secret,
),
(
format!("let api_key: &str = \"{typed}\";"),
typed.clone(),
SecretKind::Secret,
),
(
format!("{{\\\"password\\\": \\\"{typed}\\\"}}"),
typed,
SecretKind::Secret,
),
(
format!("SENDGRID_API_KEY={sendgrid}"),
sendgrid,
SecretKind::Secret,
),
(
"aws configure set aws_secret_access_key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
.to_string(),
"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
SecretKind::AwsSecretKey,
),
(
"AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
SecretKind::AwsSecretKey,
),
(
"{\\\"SecretAccessKey\\\": \\\"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\\\"}"
.to_string(),
"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
SecretKind::AwsSecretKey,
),
(
"\"SecretAccessKey\": \"/K7MDENG/bPxRfiCYEXAMPLEKEYwJalrXUtnFEMI\",".to_string(),
"/K7MDENG/bPxRfiCYEXAMPLEKEYwJalrXUtnFEMI".to_string(),
SecretKind::AwsSecretKey,
),
(
format!("client_secret: \"{slash_secret}\""),
slash_secret,
SecretKind::Secret,
),
(
format!("curl -H \"X-API-Key: {header_key}\" https://api"),
header_key.clone(),
SecretKind::Secret,
),
(
format!("curl -H 'api-key: {header_key}' https://api"),
header_key.clone(),
SecretKind::Secret,
),
(
format!("Authorization: Token {header_key}"),
header_key,
SecretKind::BearerToken,
),
(
format!("{{\"stdout\":\"keys:\\n{escaped_sk}\"}}"),
escaped_sk,
SecretKind::ApiKey,
),
(
"{\"stdout\":\"id\\nAKIAIOSFODNN7EXAMPLE\"}".to_string(),
"AKIAIOSFODNN7EXAMPLE".to_string(),
SecretKind::AwsAccessKeyId,
),
(
format!("\"key\":\"\\t{escaped_google}\""),
escaped_google,
SecretKind::GoogleApiKey,
),
(
format!("\"out\":\"\\n{escaped_jwt}\""),
escaped_jwt,
SecretKind::Jwt,
),
(format!("stripe {stripe}"), stripe, SecretKind::ApiKey),
(
format!("mysql://root:{at_pass}@db:3306/app"),
at_pass,
SecretKind::UrlCredentials,
),
(
format!("pasted this:\n{pgp_cut}"),
pgp_body,
SecretKind::PrivateKey,
),
(
format!("DEEPSEEK key {hex_key}"),
hex_key,
SecretKind::ApiKey,
),
(
format!("REDIS_URL=redis://:{redis_pass}@localhost:6379"),
redis_pass,
SecretKind::UrlCredentials,
),
(
format!("the key is\n{openssh}\nand that is all"),
openssh.lines().nth(2).unwrap().to_string(),
SecretKind::PrivateKey,
),
(
format!("transcript cut here:\n{rsa_cut}"),
rsa_cut.lines().nth(3).unwrap().to_string(),
SecretKind::PrivateKey,
),
(
"export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE".to_string(),
"AKIAIOSFODNN7EXAMPLE".to_string(),
SecretKind::AwsAccessKeyId,
),
(
format!("aws_secret_access_key = {aws_secret}"),
aws_secret,
SecretKind::AwsSecretKey,
),
(format!("token {ghp} works"), ghp, SecretKind::GithubToken),
(format!("oauth: {gho}"), gho, SecretKind::GithubToken),
(ghs.clone(), ghs, SecretKind::GithubToken),
(format!("user token {ghu}."), ghu, SecretKind::GithubToken),
(format!("pat={pat}"), pat, SecretKind::GithubToken),
(format!("OPENAI key {sk_proj}"), sk_proj, SecretKind::ApiKey),
(
format!("ANTHROPIC_API_KEY={sk_ant}"),
sk_ant,
SecretKind::ApiKey,
),
(
format!("old key {sk_legacy}"),
sk_legacy,
SecretKind::ApiKey,
),
(format!("bot {slack}"), slack, SecretKind::SlackToken),
(
format!("curl -X POST {webhook}"),
webhook,
SecretKind::SlackWebhook,
),
(
format!("maps key {google}"),
google,
SecretKind::GoogleApiKey,
),
(format!("session {jwt}"), jwt, SecretKind::Jwt),
(
format!("Authorization: Bearer {bearer}"),
bearer.clone(),
SecretKind::BearerToken,
),
(
format!("curl -H \"authorization: bearer {bearer}\" https://api"),
bearer,
SecretKind::BearerToken,
),
(
format!("Authorization: Basic {basic}=="),
basic,
SecretKind::BasicAuth,
),
(
format!("DATABASE_URL=postgres://admin:{url_pass}@db.internal:5432/app"),
url_pass,
SecretKind::UrlCredentials,
),
(
format!("DB_PASSWORD={assigned}"),
assigned.clone(),
SecretKind::Secret,
),
(
format!("{{\"api_key\": \"{assigned}\"}}"),
assigned.clone(),
SecretKind::Secret,
),
(
format!("SECRET_KEY = \"{assigned}\""),
assigned.clone(),
SecretKind::Secret,
),
(
format!("JWT_SECRET_KEY={assigned}"),
assigned.clone(),
SecretKind::Secret,
),
(
format!("SECRET_KEY_BASE={assigned}"),
assigned.clone(),
SecretKind::Secret,
),
(
format!("ENCRYPTION_KEY={assigned}"),
assigned.clone(),
SecretKind::Secret,
),
(
format!("client_secret: {assigned}"),
assigned,
SecretKind::Secret,
),
]
}
fn negatives() -> Vec<String> {
[
"let token = tokenizer.encode(text, true)?;",
"fn verify_password(password: &str) -> bool {",
"let max_tokens: usize = 4096;",
"pub secret_kind: SecretKind,",
"password: String,",
"token: Option<String>,",
"api_key = os.environ[\"OPENAI_API_KEY\"]",
"token = get_token()",
"export GITHUB_TOKEN=$(gh auth token)",
"api_key = \"your-api-key-here\"",
"api_key=settings.api_key_v2",
"token_count = 1234567890",
"tokenizer_path = models/bge-small-en-v1.5/tokenizer.json",
"4e1d2a9 fix(cli): handle empty input",
"commit 61b0f3dca950d146d5993c7ec8a44b7bd396ae76\nMerge: 28beb42 61b0f3d",
"id 3f2b8c1e-9d4a-4e6b-8f1c-2a7d5e9b0c3f stored",
"sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"image@sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"content_hash = 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGqLmN5vX1tY7wQ8Zr2LmN5vX1tY7wQ8Zr2LmN5v user@host",
"git clone git@github.com:org/repo.git",
"postgres://app@localhost/db",
"https://${USER}:${PASS}@host/x",
"https://user:$TOKEN@host/x",
"the bearer token is passed in the Authorization header",
"Authorization: Bearer $TOKEN",
"Authorization: Bearer <token>",
"pip install scikit-learn task-runner-v2",
"use a password manager for the secret",
"the task-runner-for-small-teams finished",
"sk-learn-pipeline-for-text-classification",
"GOOGLE_APPLICATION_CREDENTIALS=/home/me/keys/proj-123456-abcdef.json",
"private_key: /home/user/.ssh/id_ed25519",
"token_file = keys/deploy-2024.txt",
"existingSecret: postgres-credentials-v1",
"let token = Uuid::new_v4().to_string();",
"let secret = Sha256::digest(bytes);",
"PASSWORD=$DB_PASSWORD_V2",
"function sign(secret: Uint8Array, data: string) {",
" relayToken: Uint8Array<ArrayBuffer>;",
"const tokens: Uint8Array[] = [];",
" privateKey: Ed25519PrivateKey,",
"type Keys = { token: Uint8Array | null };",
" secret: Uint8Array",
" \"tokenizer_class\": \"GPT2Tokenizer\",",
" \"token_uri\": \"https://oauth2.googleapis.com/token\",",
"TOKEN_URL = \"https://api.example.com/v1/oauth/token\"",
"password_reset_url = \"https://example.com/reset?v=2\"",
" \"token_expires_at\": \"2024-01-15T10:30:00Z\",",
"const tokenExpiresAt = \"2024-01-15T10:30:00Z\";",
"$token = base64_encode(random_bytes(32));",
" \"token_created_at\": \"2024-01-15T10:30:00Z\",",
" \"password_changed_at\": \"2024-01-15T10:30:00.123Z\",",
"OAuth2Session(client_id, client_secret=OAUTH2_CLIENT_SECRET)",
"boto3.client(\"s3\", aws_secret_access_key=AWS_S3_SECRET_KEY)",
"secret = SECRET_KEY_2",
"SECRET_ARN=arn:aws:secretsmanager:us-east-1:123456789012:secret:prod-AbC1",
"let secret = hmac_sha256(&key, msg);",
"token = urlsafe_b64encode(os.urandom(32))",
"uses: docker://node:20@sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"skopeo inspect docker://alpine:3.19@sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
]
.into_iter()
.map(str::to_string)
.chain([[" private_key: Ed25519", "PrivateKey"].concat()])
.collect()
}
fn keep(line: &str) -> (String, String) {
(line.to_string(), line.to_string())
}
fn swap(line: String, expected: String) -> (String, String) {
(line, expected)
}
fn sample(name: &'static str, lines: Vec<(String, String)>) -> (&'static str, String, String) {
let (input, expected): (Vec<String>, Vec<String>) = lines.into_iter().unzip();
(name, input.join("\n"), expected.join("\n"))
}
fn fixture_corpus() -> Vec<(&'static str, String, String)> {
let t = noise(22, 100);
let t2 = noise(16, 101);
let amp = format!("{}&{}", noise(3, 102), noise(11, 103));
let url_pass = format!("S3cretPw{}", noise(6, 104));
let ghp = ["gh", "p_"].concat() + &noise(36, 105);
let ghs = ["gh", "s_"].concat() + &noise(36, 106);
let sk = ["s", "k-proj-"].concat() + &noise(48, 107);
let sendgrid = format!(
"{}.{}.{}",
["S", "G"].concat(),
noise(22, 108),
noise(43, 109)
);
let bearer = noise(40, 110);
let key_id = noise(40, 111);
let jwt = format!(
"{}{}.{}{}.{}",
["ey", "J"].concat(),
noise(30, 112),
["ey", "J"].concat(),
noise(60, 113),
noise(43, 114)
);
let google = ["AI", "za"].concat() + &noise(35, 115);
let slack = ["xo", "xb-"].concat() + "123456789012-1234567890123-" + &noise(24, 116);
let (a, b) = (noise(64, 117), noise(64, 118));
let d = "-".repeat(5);
let begin = format!("{d}BEGIN {}{d}", "PRIVATE KEY");
let end = format!("{d}END {}{d}", "PRIVATE KEY");
let sha = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08";
let aws_secret = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
let s = "[REDACTED:secret]";
let xoxd = ["xo", "xd-"].concat() + &noise(24, 212) + "%2B" + &noise(20, 213) + "%3D%3D";
let ppk_private = noise(64, 210);
let ppk_public = noise(64, 211);
let slash_pass = format!("{}/{}", noise(6, 200), noise(6, 201));
let glpat = ["glp", "at-"].concat() + &noise(20, 202);
let npm = ["np", "m_"].concat() + &noise(36, 203);
let hf = ["h", "f_"].concat() + &noise(34, 204);
let stripe_test = ["s", "k_test_"].concat() + &noise(24, 205);
let xoxc = ["xo", "xc-"].concat() + "123456789012-1234567890123-" + &noise(24, 206);
let xoxe = ["xo", "xe-1-"].concat() + &noise(40, 207);
let xoxe_dot = ["xo", "xe.xoxp-1-"].concat() + &noise(40, 208);
let langfuse = ["s", "k-lf-"].concat() + "3f2b8c1e-9d4a-4e6b-8f1c-2a7d5e9b0c3f";
let letters_only = ["abcDEFghiJKLmno", "PQRstuVWXyzABcdEF"].concat();
let basic = noise(24, 209);
let symbols = ["kT#vQ", "!pzR&mW@xLs"].concat();
let phrase = ["correct horse ", "battery staple"].concat();
let low = ["admin", "123_dev"].concat();
let year = ["Welcome", "2024"].concat();
let pg_year = ["Postgres", "2024"].concat();
let licence = ["AB12-CD34", "-EF56-GH78"].concat();
let hex64 = "a3f9c1e7b5d20846".repeat(4);
let address = "a3f9c1e7b5d20846b5d2".repeat(2);
let uuid = "3f2b8c1e-9d4a-4e6b-8f1c-2a7d5e9b0c3f";
let padded = format!("{}==", noise(20, 119));
let git_sha = "61b0f3dca950d146d5993c7ec8a44b7bd396ae76";
let b64 = format!("{}=", noise(19, 120));
let long = noise(800, 300);
let tskey = ["tskey", "-auth-"].concat() + &noise(40, 301);
let spaced = format!("{}#{} {}", noise(5, 302), noise(4, 303), noise(3, 304));
let ghp_pattern = ["gh", "p_"].concat() + "[A-Za-z0-9]{36}";
let letters24 = letters(24, 305);
let letters16 = letters(16, 306);
let pass_word = ["MyPass", "!word"].concat();
let pass_at = ["Pass", "@1234"].concat();
let hash_bang = ["#Secure", "!Pw"].concat();
let ppk_private2 = noise(64, 214);
let dice_the = ["orbit velvet ", "the cactus lantern"].concat();
let dice_to = ["gravel to ", "pickle mantis"].concat();
let hex20 = "8f3a9c2e7b1d4f6a0c5e";
let secure_colon = ["#Secure", ":pw"].concat();
let secure_plus = ["#Secure", "+pw"].concat();
vec![
sample(
"env file",
vec![
swap(
format!("DATABASE_URL=postgres://admin:{url_pass}@db.internal:5432/app"),
"DATABASE_URL=postgres://[REDACTED:url_credentials]@db.internal:5432/app"
.to_string(),
),
swap(format!("DB_PASSWORD={amp}"), format!("DB_PASSWORD={s}")),
swap(format!("DB_PASSWORD_PROD={t}"), format!("DB_PASSWORD_PROD={s}")),
swap(format!("SECRET_KEY_BASE={t}"), format!("SECRET_KEY_BASE={s}")),
swap(format!("JWT_SECRET_KEY={t}"), format!("JWT_SECRET_KEY={s}")),
swap(format!("ENCRYPTION_KEY={t}"), format!("ENCRYPTION_KEY={s}")),
swap(
"AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE".to_string(),
"AWS_ACCESS_KEY_ID=[REDACTED:aws_access_key_id]".to_string(),
),
swap(
format!("AWS_SECRET_ACCESS_KEY={aws_secret}"),
"AWS_SECRET_ACCESS_KEY=[REDACTED:aws_secret_key]".to_string(),
),
swap(
format!("OPENAI_API_KEY={sk}"),
"OPENAI_API_KEY=[REDACTED:api_key]".to_string(),
),
swap(format!("SENDGRID_API_KEY={sendgrid}"), format!("SENDGRID_API_KEY={s}")),
keep("PASSWORD=$DB_PASSWORD_V2"),
keep("TOKEN_URL=https://api.example.com/v1/oauth/token"),
keep("SECRET_ARN=arn:aws:secretsmanager:us-east-1:123456789012:secret:prod-AbC1"),
keep("TOKEN_TTL_SECONDS=3600"),
keep("DEBUG=true"),
keep("PORT=8080"),
],
),
sample(
"shell history",
vec![
swap(
format!("$ export GITHUB_TOKEN={ghp}"),
"$ export GITHUB_TOKEN=[REDACTED:github_token]".to_string(),
),
swap(
format!("$ curl -H \"Authorization: Bearer {bearer}\" https://api.example.com/v1/me"),
"$ curl -H \"Authorization: Bearer [REDACTED:bearer_token]\" https://api.example.com/v1/me"
.to_string(),
),
swap(
format!(
"$ curl -H \"X-API-Key: {t}\" \"https://api.example.com/v1/hook?token={t2}&url=https://example.com/cb\""
),
format!(
"$ curl -H \"X-API-Key: {s}\" \"https://api.example.com/v1/hook?token={s}&url=https://example.com/cb\""
),
),
swap(
format!("$ aws configure set aws_secret_access_key {aws_secret}"),
"$ aws configure set aws_secret_access_key [REDACTED:aws_secret_key]".to_string(),
),
keep("$ docker login -u ci -p \"$REGISTRY_TOKEN\" registry.example.com"),
swap(
format!("$ git clone https://x-access-token:{ghs}@github.com/org/repo.git"),
"$ git clone https://x-access-token:[REDACTED:github_token]@github.com/org/repo.git"
.to_string(),
),
keep("$ git clone git@github.com:org/repo.git"),
keep("$ git log --oneline -1"),
keep("61b0f3d fix: handle empty input"),
keep("$ git log --pretty=oneline -2"),
keep("5c813d9a1f0e4b7c2d6a8e3f9b1c0d2e4f6a8b0c Rotate the JWT secret key"),
keep("61b0f3dca950d146d5993c7ec8a44b7bd396ae76 Add token refresh"),
keep("$ pip install scikit-learn task-runner-v2"),
],
),
sample(
"json config",
vec![
keep("{"),
keep(" \"type\": \"service_account\","),
keep(&format!(" \"private_key_id\": \"{key_id}\",")),
swap(
format!(" \"private_key\": \"{begin}\\n{a}\\n{b}\\n{end}\\n\","),
" \"private_key\": \"[REDACTED:private_key]\\n\",".to_string(),
),
keep(" \"client_email\": \"svc@example-project.iam.gserviceaccount.com\","),
keep(" \"token_uri\": \"https://oauth2.googleapis.com/token\","),
keep(" \"tokenizer_class\": \"GPT2Tokenizer\","),
keep(" \"token_created_at\": \"2024-01-15T10:30:00Z\","),
swap(format!(" \"api_key\": \"{t}\","), format!(" \"api_key\": \"{s}\",")),
swap(
format!(" \"SecretAccessKey\": \"{aws_secret}\""),
" \"SecretAccessKey\": \"[REDACTED:aws_secret_key]\"".to_string(),
),
keep("}"),
swap(
format!("{{\"stdout\":\"export OPENAI_API_KEY={sk}\\nDEBUG=true\\nPORT=8080\"}}"),
"{\"stdout\":\"export OPENAI_API_KEY=[REDACTED:api_key]\\nDEBUG=true\\nPORT=8080\"}"
.to_string(),
),
swap(
format!("{{\"stdout\":\"\\nPASSWORD={t}\\nDEBUG=true\"}}"),
format!("{{\"stdout\":\"\\nPASSWORD={s}\\nDEBUG=true\"}}"),
),
swap(
format!("{{\\\"password\\\": \\\"{t}\\\"}}"),
format!("{{\\\"password\\\": \\\"{s}\\\"}}"),
),
],
),
sample(
"yaml config",
vec![
keep("database:"),
swap(format!(" password: {t}"), format!(" password: {s}")),
swap(format!(" POSTGRES_PASSWORD: {amp}"), format!(" POSTGRES_PASSWORD: {s}")),
swap(format!(" credentials: deploy01:{t2}"), format!(" credentials: {s}")),
swap(format!(" secretKey: {t}"), format!(" secretKey: {s}")),
keep(" existingSecret: postgres-credentials-v1"),
keep(" private_key_path: /home/user/.ssh/id_ed25519"),
keep(" token_ttl: 3600"),
swap(format!(" X-Api-Key: {padded}"), format!(" X-Api-Key: {s}")),
keep("credentials:"),
swap(format!(" token: {t}"), format!(" token: {s}")),
keep("secret:"),
swap(format!(" password: {t}"), format!(" password: {s}")),
keep("data:"),
swap(format!(" password: {b64}"), format!(" password: {s}")),
keep(" username: YWRtaW4="),
swap(format!(":password: {t}"), format!(":password: {s}")),
keep(&format!(" image: ghcr.io/acme/token-service:{git_sha}")),
keep(" image: ghcr.io/acme/secret-store:1.2.3-alpine"),
keep(&format!("image: docker://node:20@sha256:{sha}")),
keep("steps:"),
keep(&format!(" - uses: docker://alpine:3.19@sha256:{sha}")),
],
),
sample(
"code",
vec![
swap(
format!("const apiKey: string = \"{t}\";"),
format!("const apiKey: string = \"{s}\";"),
),
swap(
format!("let api_key: &str = \"{t}\";"),
format!("let api_key: &str = \"{s}\";"),
),
swap(
format!("def connect(password: str=\"{t}\"):"),
format!("def connect(password: str=\"{s}\"):"),
),
keep("$token = base64_encode(random_bytes(32));"),
swap(
format!("token = secret = \"{t}\""),
format!("token = secret = \"{s}\""),
),
swap(format!("token = secret = {t}"), format!("token = secret = {s}")),
keep("access_token = oauth2_token"),
swap(
"const stripeWebhookSecret =".to_string(),
"const stripeWebhookSecret =".to_string(),
),
swap(format!(" \"{t}\";"), format!(" \"{s}\";")),
swap(
"export const apiKey: string =".to_string(),
"export const apiKey: string =".to_string(),
),
swap(format!(" \"{t}\";"), format!(" \"{s}\";")),
keep("let secret = hmac_sha256;"),
keep("token = jwt_token2"),
keep("let secret = hmac_sha256(&key, msg);"),
keep("let token = Uuid::new_v4().to_string();"),
keep("function sign(secret: Uint8Array, data: string) {"),
keep(" relayToken: Uint8Array<ArrayBuffer>;"),
keep("OAuth2Session(client_id, client_secret=OAUTH2_CLIENT_SECRET)"),
keep("api_key = os.environ[\"OPENAI_API_KEY\"]"),
keep("let max_tokens: usize = 4096;"),
keep(&format!("if pem.starts_with(\"{begin}\") {{")),
keep("use sk-learn-pipeline-for-text-classification"),
],
),
sample(
"log lines",
vec![
keep("2024-01-15T10:30:00Z INFO token refreshed for user 42"),
keep("2024-01-15T10:30:01Z DEBUG request id 3f2b8c1e-9d4a-4e6b-8f1c-2a7d5e9b0c3f"),
keep(&format!(
"2024-01-15T10:30:02Z WARN commit 61b0f3dca950d146d5993c7ec8a44b7bd396ae76 image@sha256:{sha}"
)),
swap(
format!("2024-01-15T10:30:03Z ERROR upstream rejected Authorization: Bearer {bearer}"),
"2024-01-15T10:30:03Z ERROR upstream rejected Authorization: Bearer [REDACTED:bearer_token]"
.to_string(),
),
keep(
"2024-01-15T10:30:04Z INFO loaded arn:aws:secretsmanager:us-east-1:123456789012:secret:prod-AbC1",
),
swap(
format!("2024-01-15T10:30:05Z INFO session {jwt}"),
"2024-01-15T10:30:05Z INFO session [REDACTED:jwt]".to_string(),
),
swap(
format!("2024-01-15T10:30:06Z INFO maps key {google}, bot {slack}"),
"2024-01-15T10:30:06Z INFO maps key [REDACTED:google_api_key], bot [REDACTED:slack_token]"
.to_string(),
),
keep("the bearer token is passed in the Authorization header"),
keep("Authorization: Bearer $TOKEN"),
keep("https://${USER}:${PASS}@host/x"),
keep("postgres://app@localhost/db"),
],
),
(
"diff of a key",
format!("-{begin}\n-{a}\n-{b}\n-{end}\nunrelated line"),
"-[REDACTED:private_key]\nunrelated line".to_string(),
),
(
"truncated key then prose",
format!("{begin}\n{a}\nand then the paste stopped\nok"),
"[REDACTED:private_key]\nand then the paste stopped\nok".to_string(),
),
sample(
"assignment names and values",
vec![
swap(format!("DB_PASS={t}"), format!("DB_PASS={s}")),
swap(format!("MYSQL_PWD={t}"), format!("MYSQL_PWD={s}")),
swap(format!("SMTP_PASS={t}"), format!("SMTP_PASS={s}")),
swap(format!("PASSWORD=\"{symbols}\""), format!("PASSWORD=\"{s}\"")),
swap(format!("password = \"{phrase}\""), format!("password = \"{s}\"")),
swap(format!("DB_PASSWORD={low}"), format!("DB_PASSWORD={s}")),
swap(format!("password: {year}"), format!("password: {s}")),
swap(format!(" POSTGRES_PASSWORD: {pg_year}"), format!(" POSTGRES_PASSWORD: {s}")),
swap(format!("token={licence}"), format!("token={s}")),
swap(format!("PRIVATE_KEY=0x{hex64}"), format!("PRIVATE_KEY={s}")),
keep(" password: SecretStr"),
keep(" password_hash: Argon2Hash"),
keep("pass_filter = MyFilterClass"),
keep("bypass = True"),
keep("error_token = \"Failed to parse 2 items\""),
keep("PASSWORD_PROMPT = \"Enter the admin password: \""),
keep("password = getpass.getpass(\"Password:\")"),
keep("password = request.form[\"password\"]"),
keep(&format!("idempotency_token = {uuid}")),
keep(&format!("token_digest = {sha}")),
keep(" \"secretRef\": \"projects/my-proj-123/secrets/db-pass/versions/2\","),
keep(&format!("token = 0x{address}")),
keep(" image: secret-store:1.2.3-alpine"),
],
),
sample(
"assignment shapes",
vec![
swap(
format!("API_KEY: Final[str] = \"{t}\""),
format!("API_KEY: Final[str] = \"{s}\""),
),
swap(
format!("api_key: str | None = \"{t}\""),
format!("api_key: str | None = \"{s}\""),
),
swap(
format!(" apiKey?: string = \"{t}\";"),
format!(" apiKey?: string = \"{s}\";"),
),
keep("api_key: Optional[str] = None"),
swap(
format!("settings[\"api_key\"] = \"{t}\""),
format!("settings[\"api_key\"] = \"{s}\""),
),
swap(
format!("os.environ[\"API_TOKEN\"] = \"{t}\""),
format!("os.environ[\"API_TOKEN\"] = \"{s}\""),
),
keep("settings[\"api_key\"] = None"),
swap(
format!("let api_key = String::from(\"{t}\");"),
format!("let api_key = String::from(\"{s}\");"),
),
swap(
format!("password = os.getenv(\"DB_PASSWORD\", \"{t}\")"),
format!("password = os.getenv(\"DB_PASSWORD\", \"{s}\")"),
),
keep("token = os.getenv(\"API_TOKEN\")"),
keep("let secret = env::var(\"APP_SECRET\").unwrap();"),
swap(format!("if token == \"{t}\":"), format!("if token == \"{s}\":")),
swap(
format!("if (password === \"{t}\") {{"),
format!("if (password === \"{s}\") {{"),
),
keep("if token == expected_token:"),
swap(
format!("GET /login?next=%2Fcb%3Ftoken%3D{t}%26x%3D1"),
format!("GET /login?next=%2Fcb%3Ftoken%3D{s}%26x%3D1"),
),
swap(
format!("{{User:bob Token:{t2} Expiry:2024-01-15}}"),
format!("{{User:bob Token:{s} Expiry:2024-01-15}}"),
),
swap(
format!("$ cloudflared tunnel run --token {t}"),
format!("$ cloudflared tunnel run --token {s}"),
),
swap(
format!("$ deploy --api-key={t} --region eu"),
format!("$ deploy --api-key={s} --region eu"),
),
keep("$ docker login -u ci --password-stdin registry.example.com"),
keep("$ gh auth login --with-token < token.txt"),
keep("$ psql --password -h db"),
keep("export const apiKey: string ="),
keep(""),
keep(""),
keep(&format!(" \"{t}\";")),
],
),
sample(
"command lines",
vec![
swap(
format!("$ mysql -u root -p{t} app"),
format!("$ mysql -u root -p{s} app"),
),
keep("$ mysql -u root -p app"),
swap(
format!("$ docker login -u ci -p {t} registry.example.com"),
format!("$ docker login -u ci -p {s} registry.example.com"),
),
swap(
format!("$ sshpass -p {t} ssh deploy@host"),
format!("$ sshpass -p {s} ssh deploy@host"),
),
swap(
format!("$ {} admin:{t} https://api.example.com", ["cu", "rl -u"].concat()),
"$ curl -u admin:[REDACTED:basic_auth] https://api.example.com".to_string(),
),
keep("$ curl -u \"$USER:$PASS\" https://api.example.com"),
keep("$ mkdir -p build/out"),
keep("$ ssh -p 2222 deploy@host"),
keep("$ docker run -p 8080:80 nginx"),
swap(
format!("machine api.example.com login bot password {t}"),
format!("machine api.example.com login bot password {s}"),
),
keep("machine git.example.com"),
keep(" login bot"),
swap(format!(" password {t}"), format!(" password {s}")),
keep("password manager is required"),
keep("Password reset link sent to the user"),
],
),
sample(
"token formats",
vec![
swap(format!("GITLAB_TOKEN {glpat}"), "GITLAB_TOKEN [REDACTED:api_key]".to_string()),
swap(format!("//registry.npmjs.org/:_authToken={npm}"), "//registry.npmjs.org/:_authToken=[REDACTED:api_key]".to_string()),
swap(format!("hub key {hf}"), "hub key [REDACTED:api_key]".to_string()),
swap(format!("stripe test {stripe_test}"), "stripe test [REDACTED:api_key]".to_string()),
swap(format!("slack {xoxc}"), "slack [REDACTED:slack_token]".to_string()),
swap(format!("refresh {xoxe}"), "refresh [REDACTED:slack_token]".to_string()),
swap(format!("rotated {xoxe_dot}"), "rotated [REDACTED:slack_token]".to_string()),
swap(format!("langfuse {langfuse}"), "langfuse [REDACTED:api_key]".to_string()),
swap(
format!("AKIAIOSFODNN7EXAMPLE:{aws_secret}"),
"[REDACTED:aws_access_key_id]:[REDACTED:aws_secret_key]".to_string(),
),
swap(
format!("Authorization: Bearer {letters_only}"),
"Authorization: Bearer [REDACTED:bearer_token]".to_string(),
),
swap(
format!(" \"Authorization\": \"Basic {basic}\","),
" \"Authorization\": \"Basic [REDACTED:basic_auth]\",".to_string(),
),
swap(
format!(" \"authorization\": \"Token {t}\","),
" \"authorization\": \"Token [REDACTED:bearer_token]\",".to_string(),
),
keep("xoxo-gossip-girl-2007"),
keep("xapp-config-loader-v2"),
keep("npm_config_cache=/tmp/npm"),
keep("from huggingface_hub import hf_hub_download"),
keep("glpat-example"),
],
),
sample(
"url credentials",
vec![
swap(
format!("https://deploy:{slash_pass}@git.example.com/repo.git"),
"https://[REDACTED:url_credentials]@git.example.com/repo.git".to_string(),
),
swap(
format!("https://me@example.com:{t}@host.example.com/x"),
"https://[REDACTED:url_credentials]@host.example.com/x".to_string(),
),
swap(
format!("https://user:{t2}@host.example.com/a@b"),
"https://[REDACTED:url_credentials]@host.example.com/a@b".to_string(),
),
keep("postgres://user:password@localhost:5432/app"),
keep("postgres://postgres:postgres@localhost/db"),
keep("https://registry.npmjs.org:443/@scope/pkg"),
],
),
(
"key under hash comments",
format!("# {begin}\n# {a}\n# {b}\n# {end}\nnext"),
"# [REDACTED:private_key]\nnext".to_string(),
),
(
"key under slash comments",
format!("// {begin}\n// {a}\n// {end}"),
"// [REDACTED:private_key]".to_string(),
),
(
"key in php concatenation",
format!("$key = \"{begin}\\n\" .\n \"{a}\\n\" .\n \"{b}\\n\" .\n \"{end}\";"),
"$key = \"[REDACTED:private_key]\";".to_string(),
),
(
"key in read tool output with tabs",
format!(" 1\t{begin}\n 2\t{a}\n 3\t{b}\n 4\t{end}\n 5\tnext"),
" 1\t[REDACTED:private_key]\n 5\tnext".to_string(),
),
(
"truncated key in read tool output with arrows",
format!(" 1\u{2192}{begin}\n 2\u{2192}{a}\n 3\u{2192}{b}\n"),
" 1\u{2192}[REDACTED:private_key]\n".to_string(),
),
(
"putty key file",
format!(
"PuTTY-User-Key-File-3: ssh-ed25519\nEncryption: none\nComment: deploy\nPublic-Lines: 1\n{ppk_public}\nPrivate-Lines: 1\n{ppk_private}\nPrivate-MAC: {sha}"
),
format!(
"PuTTY-User-Key-File-3: ssh-ed25519\nEncryption: none\nComment: deploy\nPublic-Lines: 1\n{ppk_public}\nPrivate-Lines: 1\n[REDACTED:private_key]\nPrivate-MAC: {sha}"
),
),
sample(
"assignment near misses",
vec![
swap(format!("FIELD_ENCRYPTION_KEY={t}"), format!("FIELD_ENCRYPTION_KEY={s}")),
swap(format!("LABEL_STUDIO_API_KEY={t}"), format!("LABEL_STUDIO_API_KEY={s}")),
swap(format!("URL_SIGNING_SECRET={t}"), format!("URL_SIGNING_SECRET={s}")),
keep(&format!(" image: token-service:{git_sha}")),
keep("password = getpass.getpass(\"Enter your password: \")"),
keep("pwd = input(\"Password: \")"),
keep(" \"invalidPassword\": \"Invalid password\","),
keep(" \"newPassword\": \"New password\","),
keep(" \"passwordRule\": \"must be at least 8 characters long\","),
keep(
"password2 = forms.CharField(label=\"Password confirmation\", widget=forms.PasswordInput)",
),
keep("$ docker buildx build --secret id=npmrc2,src=$HOME/.npmrc ."),
swap(format!("$ app --token {padded}"), format!("$ app --token {s}")),
],
),
sample(
"command near misses",
vec![
keep("$ find /var/lib/mysql -name '*.err' -print"),
keep("$ docker run --name mysql -p3306:3306 mysql:8"),
swap(
format!("$ docker exec -it db mysql -uroot -p{t} app"),
format!("$ docker exec -it db mysql -uroot -p{s} app"),
),
swap(
format!("{{\"command\":\"mysql -u root -p{t} app\"}}"),
format!("{{\"command\":\"mysql -u root -p{s} app\"}}"),
),
swap(
format!("$ sshpass -p '{t}' ssh -p 2222 deploy@host"),
format!("$ sshpass -p '{s}' ssh -p 2222 deploy@host"),
),
keep("$ sshpass -e ssh -p 2222 deploy@host"),
],
),
sample(
"token and url near misses",
vec![
swap(format!("d cookie {xoxd}"), "d cookie [REDACTED:slack_token]".to_string()),
swap(
format!("AKIAIOSFODNN7EXAMPLE\n{aws_secret}"),
format!("[REDACTED:aws_access_key_id]\n{aws_secret}"),
),
keep("git+ssh://git@github.com:acme/repo.git@v1.2.0"),
],
),
(
"truncated key in php concatenation",
format!("$key = \"{begin}\\n\" .\n \"{a}\\n\" .\n \"{b}\\n\" ."),
"$key = \"[REDACTED:private_key]\\n\" .".to_string(),
),
(
"putty key file cut before all its lines",
format!("Private-Lines: 2\n{ppk_private}\nThe next lines"),
"Private-Lines: 2\n[REDACTED:private_key]\nThe next lines".to_string(),
),
sample(
"key constants in code",
vec![
keep(&format!("HEADER = \"{begin}\"")),
keep(&format!("EXPECTED = \"{sha}\"")),
keep(&format!("FOOTER = \"{end}\"")),
],
),
sample(
"round two assignments",
vec![
swap(
format!("export AWS_SESSION_TOKEN={long}"),
format!("export AWS_SESSION_TOKEN={s}"),
),
swap(
format!(" \"SessionToken\": \"{long}\","),
format!(" \"SessionToken\": \"{s}\","),
),
swap(format!("TS_AUTHKEY={tskey}"), format!("TS_AUTHKEY={s}")),
swap(
format!("$ tailscale up --authkey={tskey}"),
format!("$ tailscale up --authkey={s}"),
),
swap(format!("masterKey: \"{t}\""), format!("masterKey: \"{s}\"")),
swap(format!("SIGNINGKEY={t}"), format!("SIGNINGKEY={s}")),
keep("password_input = page.locator(\"#password\")"),
keep("const passwordInput = page.locator('input[type=\"password\"]');"),
keep("PASSWORD_SELECTOR = \"input[name=password]\""),
keep(" password: user?.password ?? \"\","),
keep("{\"password\": \"can't be blank\"}"),
keep("{\"password\": \"does not match the confirmation\"}"),
swap(
format!("DB_PASSWORD=\"{spaced}\""),
format!("DB_PASSWORD=\"{s}\""),
),
keep(&format!("token_re = re.compile(r\"{ghp_pattern}\")")),
keep("secret = client.read(\"secret/data/app2/db\")"),
keep(&format!(" image: token_service:{git_sha}")),
swap(format!("SECRET_KEY={letters24}"), format!("SECRET_KEY={s}")),
swap(format!("DB_PASSWORD={letters16}"), format!("DB_PASSWORD={s}")),
keep("secret_key = loadSecretKeyFromEnvironment"),
keep(" \"token\": \"PascalCaseIdentifierName\","),
keep("secret: projects/123456789012/secrets/db-pass/versions/latest"),
swap(format!("secret: {aws_secret}"), format!("secret: {s}")),
swap(
format!("$ vault login --password {t}"),
format!("$ vault login --password {s}"),
),
],
),
sample(
"round three",
vec![
swap(
format!("$ kubectl exec -it mysql-0 -- mysql -uroot -p{t}"),
format!("$ kubectl exec -it mysql-0 -- mysql -uroot -p{s}"),
),
swap(
format!("$ bash -c 'mysqlimport -uroot -p{t} db rows.csv'"),
format!("$ bash -c 'mysqlimport -uroot -p{s} db rows.csv'"),
),
keep("const passwordInput = '#user_pass';"),
keep("PASSWORD_SELECTOR = \"input[name=pwd]\""),
keep(" password: config?.dbPass ?? \"\","),
keep("const passwordInput = '#login-field';"),
keep("{\"password\": \"minimum 8 characters\"}"),
keep("{\"password\": \"please try again\"}"),
keep("{\"password\": \"wrong credentials provided\"}"),
swap(format!("API_KEYS={t}"), format!("API_KEYS={s}")),
swap(format!("TOKENS={t}"), format!("TOKENS={s}")),
swap(format!("GITHUB_TOKENS={t}"), format!("GITHUB_TOKENS={s}")),
swap(format!("SECRETVALUE={t}"), format!("SECRETVALUE={s}")),
keep(&format!("TOKENIZER_PATH={t}")),
swap(
format!("SECRET_KEY = config(\"SECRET_KEY\", default=\"{t}\")"),
format!("SECRET_KEY = config(\"SECRET_KEY\", default=\"{s}\")"),
),
swap(
format!("SECRET_KEY = env(\"SECRET_KEY\", default=\"{t}\")"),
format!("SECRET_KEY = env(\"SECRET_KEY\", default=\"{s}\")"),
),
swap(
format!(" 'secret' => env('JWT_SECRET', '{t}'),"),
format!(" 'secret' => env('JWT_SECRET', '{s}'),"),
),
keep(" 'secret' => env('JWT_SECRET'),"),
],
),
sample(
"round four",
vec![
swap(format!("DB_PASSWORD={pass_word}"), format!("DB_PASSWORD={s}")),
swap(format!("DB_PASSWORD={pass_at}"), format!("DB_PASSWORD={s}")),
swap(format!("DB_PASSWORD={hash_bang}"), format!("DB_PASSWORD={s}")),
keep("PASSWORD_SELECTOR = \"input#pwd\""),
keep("{\"password\": \"please try again later\"}"),
keep("{\"password\": \"minimum eight characters required\"}"),
swap(format!("APIKEYVALUE={t}"), format!("APIKEYVALUE={s}")),
swap(format!("GITHUBTOKENVALUE={t}"), format!("GITHUBTOKENVALUE={s}")),
swap(format!("DBPASSWORDPROD={t}"), format!("DBPASSWORDPROD={s}")),
swap(format!("API_KEYPROD={t}"), format!("API_KEYPROD={s}")),
swap(format!("API_KEYV2={t}"), format!("API_KEYV2={s}")),
swap(format!("PRIVATE_KEYB64={t}"), format!("PRIVATE_KEYB64={s}")),
keep(&format!("KEYBOARDLAYOUT={t}")),
keep(&format!("TOKEN_TYPES={t}")),
keep(&format!("secret_names={t}")),
swap(
format!("SECRET_KEY = env.str(\"SECRET_KEY\", default=\"{t}\")"),
format!("SECRET_KEY = env.str(\"SECRET_KEY\", default=\"{s}\")"),
),
],
),
sample(
"round two commands",
vec![
swap(
format!("{{\"command\":\"docker compose exec db mysql -uroot -p{t} app\"}}"),
format!("{{\"command\":\"docker compose exec db mysql -uroot -p{s} app\"}}"),
),
swap(
format!("$ docker run --rm -it mysql:8 mysql -h db -uroot -p{t}"),
format!("$ docker run --rm -it mysql:8 mysql -h db -uroot -p{s}"),
),
swap(
format!("$ ssh db1 mysql -uroot -p{t}"),
format!("$ ssh db1 mysql -uroot -p{s}"),
),
swap(
format!("$ docker exec -it mysql mysql -uroot -p{t}"),
format!("$ docker exec -it mysql mysql -uroot -p{s}"),
),
swap(
format!("$ sudo /usr/bin/mysql -uroot -p{t}"),
format!("$ sudo /usr/bin/mysql -uroot -p{s}"),
),
keep("$ docker exec mysql-db cp -pr /a /b"),
keep("$ apt install mysql-server -y && cp -pr /etc/mysql /backup"),
],
),
sample(
"residual names, phrases and defaults",
vec![
swap(format!("myAPIKEYPROD={t}"), format!("myAPIKEYPROD={s}")),
swap(format!("dbPASSWORDPROD={t}"), format!("dbPASSWORDPROD={s}")),
swap(format!("appSECRETVALUE={t}"), format!("appSECRETVALUE={s}")),
keep(&format!("myKEYBOARDLAYOUT={t}")),
keep(&format!("myTOKENTYPES={t}")),
swap(
format!("DB_PASSWORD=\"{dice_the}\""),
format!("DB_PASSWORD=\"{s}\""),
),
swap(
format!("{{\"password\": \"{dice_to}\"}}"),
format!("{{\"password\": \"{s}\"}}"),
),
keep("{\"password\": \"your session expired sign in again\"}"),
keep("{\"password\": \"the field is required\"}"),
swap(
format!("SECRET_KEY = Env.str(\"SECRET_KEY\", default=\"{t}\")"),
format!("SECRET_KEY = Env.str(\"SECRET_KEY\", default=\"{s}\")"),
),
swap(
format!("SECRET_KEY = ENV.str(\"SECRET_KEY\", default=\"{t}\")"),
format!("SECRET_KEY = ENV.str(\"SECRET_KEY\", default=\"{s}\")"),
),
keep("SECRET_KEY = Env.str(\"SECRET_KEY\")"),
],
),
sample(
"residual commands",
vec![
swap(
format!("$ sudo -E mysql -uroot -p{t}"),
format!("$ sudo -E mysql -uroot -p{s}"),
),
swap(
format!("$ sudo -u admin -E mysqldump -uroot -p{t} app"),
format!("$ sudo -u admin -E mysqldump -uroot -p{s} app"),
),
swap(
format!(
" test: [\"CMD\", \"mysqladmin\", \"ping\", \"-h\", \"localhost\", \"-uroot\", \"-p{t}\"]"
),
format!(
" test: [\"CMD\", \"mysqladmin\", \"ping\", \"-h\", \"localhost\", \"-uroot\", \"-p{s}\"]"
),
),
swap(
format!(" test: ['CMD', 'mysql', '-uroot', '-p{t}', '-e', 'SELECT 1']"),
format!(" test: ['CMD', 'mysql', '-uroot', '-p{s}', '-e', 'SELECT 1']"),
),
swap(
format!(" test: [\"CMD\", \"mysqladmin\" ,\"ping\", \"-uroot\", \"-p{t}\"]"),
format!(" test: [\"CMD\", \"mysqladmin\" ,\"ping\", \"-uroot\", \"-p{s}\"]"),
),
keep(" test: [\"CMD\", \"mysqladmin\", \"ping\", \"-h\", \"localhost\"]"),
keep(" test: [\"CMD\", \"mysqladmin\", \"ping\", \"-p$MYSQL_ROOT_PASSWORD\"]"),
keep(" command: [\"--name\", \"mysql\", \"-p\", \"3306\"]"),
swap(
format!("$ sshpass -v -p {t} ssh deploy@host"),
format!("$ sshpass -v -p {s} ssh deploy@host"),
),
swap(
format!("$ sshpass -v -p{t} ssh deploy@host"),
format!("$ sshpass -v -p{s} ssh deploy@host"),
),
keep("$ sshpass -v -e ssh deploy@host"),
swap(
format!("$ docker login -u ci -p{t} registry.example.com"),
format!("$ docker login -u ci -p{s} registry.example.com"),
),
keep("$ docker login -u ci -p\"$REGISTRY_TOKEN\" registry.example.com"),
swap(
format!("$ {} admin:{t} https://api.example.com", ["cu", "rl -sSu"].concat()),
format!("$ curl -sSu admin:[REDACTED:basic_auth] https://api.example.com"),
),
swap(
format!("$ {} admin:{t} https://api.example.com", ["cu", "rl -fsSL -u"].concat()),
format!("$ curl -fsSL -u admin:[REDACTED:basic_auth] https://api.example.com"),
),
keep("$ curl -sSu \"$USER:$PASS\" https://api.example.com"),
keep("$ curl -sSL https://example.com/install.sh | sh"),
swap(
format!("$ skopeo login -u ci -p {t} quay.io"),
format!("$ skopeo login -u ci -p {s} quay.io"),
),
swap(
format!("$ buildah login -u ci -p {t} quay.io"),
format!("$ buildah login -u ci -p {s} quay.io"),
),
swap(
format!("$ oras login -u ci -p {t} ghcr.io"),
format!("$ oras login -u ci -p {s} ghcr.io"),
),
keep("$ skopeo login -u ci -p \"$TOKEN\" quay.io"),
],
),
sample(
"residual tokens",
vec![
swap(
format!("join the tailnet with {tskey} on the node"),
format!("join the tailnet with {s} on the node"),
),
swap(format!("TS_AUTHKEY={tskey}"), format!("TS_AUTHKEY={s}")),
keep("tailscale auth keys start with tskey-auth- and expire"),
swap(
format!("https://app.example.com/cb?state=%7B%22token%22%3A%22{t}%22%7D"),
format!("https://app.example.com/cb?state=%7B%22token%22%3A%22{s}%22%7D"),
),
swap(
format!("https://app.example.com/cb?state=%7B%22token%22%3A%20%22{t}%22%2C%22u%22%3A1%7D"),
format!("https://app.example.com/cb?state=%7B%22token%22%3A%20%22{s}%22%2C%22u%22%3A1%7D"),
),
swap(
format!("https://app.example.com/login?next=%2Fcb%253Ftoken%253D{t}%2526x%253D1"),
format!("https://app.example.com/login?next=%2Fcb%253Ftoken%253D{s}%2526x%253D1"),
),
],
),
sample(
"residual over-redaction",
vec![
keep("PASSWORD_SELECTOR = \"form#login>input[name=pwd]\""),
keep("PASSWORD_SELECTOR = \"form#login > input[name=pwd]\""),
keep("PASSWORD_SELECTOR = \"#pwd:focus\""),
keep("const passwordInput = 'input[type=password]:not(:disabled)';"),
keep(&format!(" image: auth_token:{sha}")),
keep(&format!(" image: registry.example.com/auth_token:{sha}")),
swap(format!("auth_token: {t}"), format!("auth_token: {s}")),
swap(
format!("error: auth_token:{hex20}"),
format!("error: auth_token:{s}"),
),
swap(
format!("INFO: session_token:{hex20}"),
format!("INFO: session_token:{s}"),
),
swap(
format!("DB_PASSWORD=\"{secure_colon}\""),
format!("DB_PASSWORD=\"{s}\""),
),
swap(
format!("DB_PASSWORD=\"{secure_plus}\""),
format!("DB_PASSWORD=\"{s}\""),
),
keep("PASSWORD_SELECTOR = \"#login-form input:focus-visible\""),
keep("PASSWORD_SELECTOR = \"form#login > div.field > input[name=pwd]\""),
],
),
(
"putty key file in read tool output",
format!(
" 5\tPublic-Lines: 1\n 6\t{ppk_public}\n 7\tPrivate-Lines: 2\n 8\t{ppk_private}\n 9\t{ppk_private2}\n 10\tPrivate-MAC: {sha}"
),
format!(
" 5\tPublic-Lines: 1\n 6\t{ppk_public}\n 7\tPrivate-Lines: 2\n 8\t[REDACTED:private_key]\n 10\tPrivate-MAC: {sha}"
),
),
(
"putty key file in read tool output with arrows",
format!(
" 7\u{2192}Private-Lines: 2\n 8\u{2192}{ppk_private}\n 9\u{2192}{ppk_private2}\n 10\u{2192}Private-MAC: {sha}"
),
format!(
" 7\u{2192}Private-Lines: 2\n 8\u{2192}[REDACTED:private_key]\n 10\u{2192}Private-MAC: {sha}"
),
),
(
"putty private lines header in read tool output without key lines",
" 7\tPrivate-Lines: 2\n 8\tThe next lines".to_string(),
" 7\tPrivate-Lines: 2\n 8\tThe next lines".to_string(),
),
]
}
fn letters(len: usize, seed: u64) -> String {
noise(len, seed)
.bytes()
.map(|b| match b {
b'0'..=b'9' => (b'a' + (b - b'0') * 2) as char,
_ => b as char,
})
.collect()
}
#[test]
fn fixture_corpus_redacts_exactly_and_once() {
let mut failures = Vec::new();
for (name, input, expected) in fixture_corpus() {
let once = redact(&input).text;
let twice = redact(&once).text;
for (got, want) in once.lines().zip(expected.lines()) {
if got != want {
failures.push(format!("{name}\n got: {got}\n want: {want}"));
}
}
if once.lines().count() != expected.lines().count() || once != expected {
failures.push(format!("{name}: output differs\n{once}"));
}
if twice != once {
failures.push(format!("{name}: second pass changed\n{twice}"));
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
#[test]
fn every_positive_is_redacted_with_its_kind() {
for (input, secret, kind) in positives() {
let out = redact(&input);
assert!(
!out.text.contains(&secret),
"{} left in: {}",
kind.as_str(),
out.text
);
let marker = format!("[REDACTED:{}]", kind.as_str());
assert!(out.text.contains(&marker), "no {marker} in: {}", out.text);
assert!(
out.findings.iter().any(|f| f.kind == kind && f.count >= 1),
"{:?} not reported for: {input}",
kind
);
}
}
#[test]
fn no_negative_is_touched() {
for input in negatives() {
let out = redact(&input);
assert_eq!(out.text, input);
assert!(out.findings.is_empty(), "{:?} for: {input}", out.findings);
}
}
#[test]
fn only_the_secret_is_replaced_not_its_surroundings() {
let pass = "S3cretPw".to_string() + &noise(6, 40);
let input = format!("DATABASE_URL=postgres://admin:{pass}@db.internal:5432/app");
assert_eq!(
redact(&input).text,
"DATABASE_URL=postgres://[REDACTED:url_credentials]@db.internal:5432/app"
);
let value = noise(20, 41);
assert_eq!(
redact(&format!("DB_PASSWORD={value} next")).text,
"DB_PASSWORD=[REDACTED:secret] next"
);
}
#[test]
fn findings_count_each_kind_once_per_match() {
let a = ["gh", "p_"].concat() + &noise(36, 50);
let b = ["gh", "p_"].concat() + &noise(36, 51);
let out = redact(&format!("{a} and {b} and AKIAIOSFODNN7EXAMPLE"));
assert_eq!(
out.findings,
vec![
Finding {
kind: SecretKind::GithubToken,
count: 2
},
Finding {
kind: SecretKind::AwsAccessKeyId,
count: 1
},
]
);
}
#[test]
fn redacting_twice_changes_nothing() {
let all = positives()
.into_iter()
.map(|(input, _, _)| input)
.chain(negatives())
.chain([
format!("https://admin:token={}/Lm2Pq;@host", noise(12, 30)),
format!("credentials: deploy01:{}", noise(10, 38)),
format!(
"{}{}{}{}",
["AI", "za"].concat(),
noise(35, 31),
["gh", "p_"].concat(),
noise(36, 32)
),
])
.collect::<Vec<_>>()
.join("\n");
let once = redact(&all);
assert!(once.changed());
let twice = redact(&once.text);
assert_eq!(twice.text, once.text);
assert!(twice.findings.is_empty(), "{:?}", twice.findings);
}
#[test]
fn redact_memory_covers_content_and_context() {
let key = ["gh", "p_"].concat() + &noise(36, 60);
let mut memory = Memory::new(
format!("pushed with {key}"),
MemoryType::Episodic,
"test".to_string(),
String::new(),
);
memory.context = Some(format!("export GH_TOKEN={key}"));
redact_memory(&mut memory);
assert!(!memory.content.contains(&key));
assert!(!memory.context.as_deref().unwrap().contains(&key));
assert!(memory.content.contains("[REDACTED:github_token]"));
}
#[test]
fn a_header_constant_in_code_does_not_swallow_the_code_up_to_its_footer() {
let d = "-".repeat(5);
let header = format!("const HEADER: &str = \"{d}BEGIN {}{d}\";\n", "PRIVATE KEY");
let code = "fn parse(line: &str) -> Option<Key> { todo!() }\n".repeat(300);
let footer = format!("const FOOTER: &str = \"{d}END {}{d}\";\n", "PRIVATE KEY");
let out = redact(&format!("{header}{code}{footer}"));
assert!(out.text.contains(&code));
}
#[test]
fn many_unterminated_headers_stay_linear() {
let d = "-".repeat(5);
let begin = format!("{d}BEGIN {}{d}", "PRIVATE KEY");
for unit in [format!("{begin} xx "), format!("{begin}\nVersion: ")] {
let time = |n: usize| {
let text = unit.repeat(n);
(0..3)
.map(|_| {
let start = std::time::Instant::now();
assert!(!redact(&text).changed());
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(t_large < t_small * 10, "{t_small:?} vs {t_large:?}");
}
}
#[test]
fn yaml_values_with_inner_separators_redact_once() {
for (input, secret_named) in [
(format!("credentials: deploy01:{}", noise(10, 38)), true),
(format!("credentials: admin2024={}", noise(22, 39)), true),
(format!("credentials: admin2024 = {}", noise(22, 40)), false),
] {
let once = redact(&input);
assert_eq!(once.changed(), secret_named, "{input}");
assert_eq!(redact(&once.text).text, once.text);
}
}
#[test]
fn rejected_assignments_stay_linear() {
let time = |n: usize| {
let text = format!("token=a{}", "&token:b".repeat(n));
(0..3)
.map(|_| {
let start = std::time::Instant::now();
redact(&text);
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(t_large < t_small * 10, "{t_small:?} vs {t_large:?}");
}
#[test]
fn long_values_holding_names_stay_linear() {
for (shape, unit) in [
("token={} =", "xtoken:"),
("token={}(", "xtoken:"),
("token={}", "xtoken:"),
("password=\"{}", "a b password=\"c d "),
("{}", "token=x%26"),
("token={}get(\"a\", \"bbbbbbbbbbbb\")", "xtoken:"),
] {
let time = |n: usize| {
let text = shape.replace("{}", &unit.repeat(n));
(0..3)
.map(|_| {
let start = std::time::Instant::now();
redact(&text);
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(
t_large < t_small * 10,
"{shape}: {t_small:?} vs {t_large:?}"
);
}
}
#[test]
fn glued_tokens_stay_linear() {
let unit = ["AI", "za"].concat() + &"B".repeat(35);
let time = |n: usize| {
let text = unit.repeat(n);
(0..3)
.map(|_| {
let start = std::time::Instant::now();
assert!(redact(&text).changed());
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(1_000), time(4_000));
assert!(t_large < t_small * 10, "{t_small:?} vs {t_large:?}");
}
#[test]
fn header_and_footer_strings_without_key_material_are_kept() {
let d = "-".repeat(5);
let begin = format!("{d}BEGIN {}{d}", "PRIVATE KEY");
let end = format!("{d}END {}{d}", "PRIVATE KEY");
for input in [
format!("if pem.starts_with(\"{begin}\") {{"),
format!("HEADER = \"{begin}\"\nFOOTER = \"{end}\""),
format!("{begin}\n...\n{end}"),
format!(
"BEGIN = \"{begin}\"\nKEYDIR = \"/etc/ssl/private/example/keysdir\"\nEND = \"{end}\""
),
format!(
"HEADER = \"{begin}\"\nEXPECTED = \"{}\"\nFOOTER = \"{end}\"",
"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
),
] {
let out = redact(&input);
assert_eq!(out.text, input);
}
}
#[test]
fn keys_split_across_code_literals_or_indented_are_redacted_whole() {
let d = "-".repeat(5);
let begin = format!("{d}BEGIN {}{d}", "PRIVATE KEY");
let end = format!("{d}END {}{d}", "PRIVATE KEY");
let (a, b) = (noise(64, 90), noise(44, 91));
for input in [
format!("String k = \"{begin}\\n\" +\n \"{a}\\n\" +\n \"{b}\\n\" +\n \"{end}\";"),
format!("key: |\n {begin}\n {a}\n {b}\n {end}\nnext: 1"),
format!("PRIVATE_KEY=\"{begin} {a} {b} {end}\""),
] {
let out = redact(&input);
assert!(
!out.text.contains(&a) && !out.text.contains(&b),
"{}",
out.text
);
assert!(!out.text.contains("END"), "{}", out.text);
assert_eq!(out.findings[0].kind, SecretKind::PrivateKey);
}
}
#[test]
fn truncated_keys_after_spaces_indents_or_quotes_are_redacted() {
let d = "-".repeat(5);
let begin = format!("{d}BEGIN {}{d}", "PRIVATE KEY");
let openssh = format!("{d}BEGIN OPENSSH {}{d}", "PRIVATE KEY");
let pgp = format!("{d}BEGIN PGP {}{d}", "PRIVATE KEY BLOCK");
let pgp_end = format!("{d}END PGP {}{d}", "PRIVATE KEY BLOCK");
let end_label = format!("{d}END {}{d}", "PRIVATE KEY");
let (a, b) = (noise(64, 95), noise(64, 96));
for input in [
format!("PRIVATE_KEY=\"{begin} {a} {b}"),
format!("key: |\n {openssh}\n {a}\n {b}"),
format!(" {pgp}\n Version: GnuPG v2.0.22\n\n {a}\n {b}\n {pgp_end}\n"),
format!("-{begin}\n-{a}\n-{b}\n-{end_label}\n"),
format!("+{begin}\n+{a}\n+{b}\n"),
format!("> {begin}\n> {a}\n> {b}\n> next"),
format!("{{\"text\": \"{begin}\\r\\n{a}\\r\\n{b}\\r\\n"),
] {
let out = redact(&input);
assert!(
!out.text.contains(&a) && !out.text.contains(&b),
"{}",
out.text
);
}
}
#[test]
fn prose_after_a_truncated_key_is_kept() {
let d = "-".repeat(5);
let input = format!(
"{d}BEGIN {}{d}\n{}\nand then the paste stopped",
"PRIVATE KEY",
noise(64, 97)
);
assert_eq!(
redact(&input).text,
"[REDACTED:private_key]\nand then the paste stopped"
);
for tail in ["\n", "\nok\n", "\n```\nok\n"] {
assert_eq!(
redact(&format!("{input}{tail}")).text,
format!("[REDACTED:private_key]\nand then the paste stopped{tail}")
);
}
}
#[test]
fn quoted_assigned_secrets_with_symbols_are_redacted_whole() {
let value = format!("{}$!#{}", noise(6, 92), noise(6, 93));
assert_eq!(
redact(&format!("DB_PASSWORD=\"{value}\"")).text,
"DB_PASSWORD=\"[REDACTED:secret]\""
);
assert_eq!(
redact(&format!("{{'secret': '{value}', 'n': 1}}")).text,
"{'secret': '[REDACTED:secret]', 'n': 1}"
);
let plain = noise(20, 98);
assert_eq!(
redact(&format!(r#"{{\"password\": \"{plain}\"}}"#)).text,
r#"{\"password\": \"[REDACTED:secret]\"}"#
);
}
#[test]
fn redact_memory_reports_whether_it_changed_anything() {
let mut clean = Memory::new(
"nothing secret".to_string(),
MemoryType::Episodic,
"test".to_string(),
String::new(),
);
assert!(!redact_memory(&mut clean));
let mut dirty = clean.clone();
dirty.context = Some(["gh", "p_"].concat() + &noise(36, 94));
assert!(redact_memory(&mut dirty));
}
#[test]
fn runtime_grows_linearly_with_input_size() {
let key = ["gh", "p_"].concat() + &noise(36, 70);
let paragraph = format!(
"user: why does the build fail?\nassistant: the linker ran out of memory; \
token = tokenizer.encode(text) and commit 61b0f3dca950d146d5993c7ec8a44b7bd396ae76 \
fixed it. use {key} to push.\n"
);
let small = paragraph.repeat(1_000);
let large = paragraph.repeat(4_000);
let time = |text: &str| {
(0..3)
.map(|_| {
let start = std::time::Instant::now();
let out = redact(text);
assert!(!out.text.contains(&key));
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(&small), time(&large));
assert!(
t_large < t_small * 10,
"{t_small:?} for {} bytes vs {t_large:?} for {} bytes",
small.len(),
large.len()
);
}
#[test]
fn percent_escapes_selectors_and_mapping_values_stay_linear() {
for (shape, unit) in [
("{}", "%22token%22%3A%22x%2522"),
("token%3A{}", "%20"),
("token%3A%22{}", "a%2520"),
("{}", "%253Ftoken%253Dx%2526"),
("{}", "%2522token%2522%253A%2522"),
("{}", "k: auth_token:x "),
("PASSWORD=\"{}\"", "#a:focus>"),
("PASSWORD=\"#a[{}\"", "b=c"),
("PASSWORD=\"#a:not({}\"", "#b"),
("{}", "myAPIKEYPROD=x "),
] {
let time = |n: usize| {
let text = shape.replace("{}", &unit.repeat(n));
(0..3)
.map(|_| {
let start = std::time::Instant::now();
redact(&text);
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(
t_large < t_small * 10,
"{shape}: {t_small:?} vs {t_large:?}"
);
}
}
#[test]
fn command_flag_runs_stay_linear() {
for unit in [
"sudo -E ",
"sudo -u admin -E ",
"sudo -E mysql -p$X ",
"\"mysql\", \"-p\", ",
"'mysql', '-p$X', ",
"sshpass -v ",
"sshpass -v -p$X ",
"curl -sSu ",
"curl -sSu $U:$P ",
"docker login -p$X ",
"tskey-auth-",
"tskey-a-xxxxxxxxxxxxxxxx ",
] {
let time = |n: usize| {
let text = unit.repeat(n);
(0..3)
.map(|_| {
let start = std::time::Instant::now();
redact(&text);
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(t_large < t_small * 10, "{unit}: {t_small:?} vs {t_large:?}");
}
}
#[test]
fn numbered_putty_lines_stay_linear() {
let key = noise(64, 400);
for (unit, changed) in [
(format!(" 7\tPrivate-Lines: 999\n 8\t{key}\n"), true),
(
" 7\tPrivate-Lines: 999\n 8\tThe next lines\n".to_string(),
false,
),
(
format!(
"Private-Lines: 3\n 8\u{2192}{key}\n 9\u{2192}{key}\n 10\u{2192}{key}\n"
),
true,
),
] {
let time = |n: usize| {
let text = format!("Private-Lines: 999\n{}", unit.repeat(n));
(0..3)
.map(|_| {
let start = std::time::Instant::now();
assert_eq!(redact(&text).changed(), changed);
start.elapsed()
})
.min()
.unwrap()
};
let (t_small, t_large) = (time(2_000), time(8_000));
assert!(t_large < t_small * 10, "{unit}: {t_small:?} vs {t_large:?}");
}
}