use crate::rules::Severity;
use crate::scan::{default_scanner, Scanner};
use std::borrow::Cow;
use std::ops::Range;
#[derive(Debug, Clone, Default)]
pub struct RedactOptions {
keep_edges: usize,
}
impl RedactOptions {
pub fn new() -> Self {
Self::default()
}
pub fn keep_edges(mut self, n: usize) -> Self {
self.keep_edges = n;
self
}
}
pub fn redact(text: &str) -> Cow<'_, str> {
redact_with(text, default_scanner(), &RedactOptions::default())
}
pub fn redact_with<'t>(text: &'t str, scanner: &Scanner, options: &RedactOptions) -> Cow<'t, str> {
let findings = scanner.scan(text);
if findings.is_empty() {
return Cow::Borrowed(text);
}
let mut merged: Vec<(Range<usize>, &str, Severity)> = Vec::with_capacity(findings.len());
for finding in &findings {
match merged.last_mut() {
Some((span, label, label_severity)) if finding.span.start < span.end => {
span.end = span.end.max(finding.span.end);
if span.start == finding.span.start && severity_rank(finding.severity) < severity_rank(*label_severity)
{
*label = finding.rule.as_ref();
*label_severity = finding.severity;
}
}
_ => merged.push((finding.span.clone(), finding.rule.as_ref(), finding.severity)),
}
}
let mut out = String::with_capacity(text.len());
let mut cursor = 0;
for (span, label, _) in merged {
out.push_str(&text[cursor..span.start]);
mask_into(&mut out, &text[span.clone()], label, options.keep_edges);
cursor = span.end;
}
out.push_str(&text[cursor..]);
Cow::Owned(out)
}
fn severity_rank(severity: Severity) -> u8 {
match severity {
Severity::Critical => 0,
Severity::High => 1,
Severity::Medium => 2,
}
}
fn mask_into(out: &mut String, secret: &str, label: &str, keep_edges: usize) {
let visible_ok = keep_edges > 0 && secret.chars().count() >= keep_edges * 2 + 8;
if visible_ok {
let head_end = secret
.char_indices()
.nth(keep_edges)
.map(|(i, _)| i)
.unwrap_or(secret.len());
let tail_start = secret
.char_indices()
.rev()
.nth(keep_edges - 1)
.map(|(i, _)| i)
.unwrap_or(secret.len());
out.push_str(&secret[..head_end]);
out.push_str("[REDACTED:");
out.push_str(label);
out.push(']');
out.push_str(&secret[tail_start..]);
} else {
out.push_str("[REDACTED:");
out.push_str(label);
out.push(']');
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn clean_text_is_returned_borrowed() {
let text = "nothing secret here, just a release note for v0.3.1";
assert!(matches!(redact(text), Cow::Borrowed(_)));
}
#[test]
fn multiple_findings_redact_in_order() {
let text = "a=AKIAIOSFODNN7EXAMPLE b=ghp_16C7e42F292c6912E7710c838347Ae178B4a done";
assert_eq!(
redact(text),
"a=[REDACTED:AWS Access Key] b=[REDACTED:GitHub Token] done"
);
}
#[test]
fn overlapping_findings_collapse_to_one_placeholder() {
let text = "key: sk-ant-api03-abcdefghijklmnopqrstuvwxyzABCDEF";
let redacted = redact(text);
assert_eq!(redacted.matches("[REDACTED:").count(), 1, "{redacted}");
assert!(!redacted.contains("api03"), "{redacted}");
}
#[test]
fn keep_edges_shows_head_and_tail_only_when_enough_stays_hidden() {
let opts = RedactOptions::new().keep_edges(2);
let scanner = crate::Scanner::new();
assert_eq!(
redact_with("AKIAIOSFODNN7EXAMPLE", &scanner, &opts),
"AK[REDACTED:AWS Access Key]LE"
);
let scanner = scanner
.with_rule("Tiny Token", crate::Severity::Medium, r"tiny_[0-9]{4}")
.unwrap();
assert_eq!(redact_with("tiny_1234", &scanner, &opts), "[REDACTED:Tiny Token]");
}
#[test]
fn redaction_survives_multibyte_neighbours() {
let text = "🔑 AKIAIOSFODNN7EXAMPLE 🔑";
assert_eq!(redact(text), "🔑 [REDACTED:AWS Access Key] 🔑");
}
}