use super::{Confidence, Finding, Severity};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Triage {
pub ranked: Vec<Finding>,
pub unranked: Vec<Finding>,
pub method: Method,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Method {
Deterministic,
Model { backend: String },
}
pub fn rank(mut findings: Vec<Finding>) -> Triage {
findings.sort_by(|a, b| {
b.severity
.cmp(&a.severity)
.then(b.confidence.cmp(&a.confidence))
.then(a.rule.cmp(&b.rule))
.then(a.title.cmp(&b.title))
});
Triage {
ranked: findings,
unranked: Vec::new(),
method: Method::Deterministic,
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ModelOrdering {
pub order: Vec<usize>,
#[serde(default)]
pub rationale: Option<String>,
}
pub fn apply_model_triage(
findings: &[Finding],
ordering: &ModelOrdering,
backend: impl Into<String>,
) -> Triage {
let mut used = vec![false; findings.len()];
let mut ranked = Vec::with_capacity(findings.len());
for &i in &ordering.order {
let Some(slot) = used.get_mut(i) else {
continue; };
if *slot {
continue; }
*slot = true;
ranked.push(findings[i].clone());
}
let unranked: Vec<Finding> = findings
.iter()
.enumerate()
.filter(|(i, _)| !used[*i])
.map(|(_, f)| f.clone())
.collect();
Triage {
ranked,
unranked,
method: Method::Model {
backend: backend.into(),
},
}
}
pub const TRIAGE_PROMPT: &str = "\
You are ordering security findings that have already been detected by other means. \
Return only a JSON object of the form {\"order\":[<indices>],\"rationale\":\"...\"} \
where each index refers to a finding in the list you were given, most important \
first. You cannot add findings, change their severity or confidence, or alter \
their evidence — anything you write other than the ordering and the rationale is \
discarded. Judge importance by what an incident responder should look at first.";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Counts {
pub critical: usize,
pub high: usize,
pub medium: usize,
pub low: usize,
pub info: usize,
pub possible_only: usize,
}
pub fn counts(findings: &[Finding]) -> Counts {
let mut c = Counts::default();
for f in findings {
match f.severity {
Severity::Critical => c.critical += 1,
Severity::High => c.high += 1,
Severity::Medium => c.medium += 1,
Severity::Low => c.low += 1,
Severity::Info => c.info += 1,
}
if f.confidence == Confidence::Possible {
c.possible_only += 1;
}
}
c
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ids::{Evidence, Subject};
fn finding(rule: &str, sev: Severity, conf: Confidence) -> Finding {
Finding::new(
rule,
format!("title for {rule}"),
sev,
conf,
Subject::File {
path: format!("/{rule}"),
},
vec![Evidence::observed("test", rule)],
)
.expect("evidence supplied")
}
#[test]
fn ranking_puts_the_worst_first_and_is_stable() {
let input = vec![
finding("b.low", Severity::Low, Confidence::Certain),
finding("a.critical", Severity::Critical, Confidence::Possible),
finding("c.high", Severity::High, Confidence::Certain),
];
let t = rank(input.clone());
let rules: Vec<&str> = t.ranked.iter().map(|f| f.rule.as_str()).collect();
assert_eq!(rules, vec!["a.critical", "c.high", "b.low"]);
assert!(t.unranked.is_empty());
let mut shuffled = input;
shuffled.reverse();
let again = rank(shuffled);
assert_eq!(
again
.ranked
.iter()
.map(|f| f.rule.clone())
.collect::<Vec<_>>(),
t.ranked.iter().map(|f| f.rule.clone()).collect::<Vec<_>>(),
"an unstable order makes two identical scans look different, which \
trains a reader to ignore the diff"
);
}
#[test]
fn confidence_breaks_a_severity_tie() {
let t = rank(vec![
finding("z.guess", Severity::High, Confidence::Possible),
finding("a.observed", Severity::High, Confidence::Certain),
]);
assert_eq!(t.ranked[0].rule, "a.observed");
}
#[test]
fn a_model_cannot_introduce_a_finding_that_was_not_detected() {
let detected = vec![finding(
"file.modified",
Severity::High,
Confidence::Certain,
)];
let ordering = ModelOrdering {
order: vec![99, 0, 42],
rationale: Some("I also found a rootkit".into()),
};
let t = apply_model_triage(&detected, &ordering, "test-backend");
assert_eq!(t.ranked.len(), 1, "only detected findings may appear");
assert_eq!(t.ranked[0].rule, "file.modified");
assert!(
t.unranked.is_empty(),
"the one real finding was placed, so nothing is left over"
);
assert!(!format!("{:?}", t.ranked).contains("rootkit"));
}
#[test]
fn model_triage_preserves_severity_confidence_and_evidence() {
let detected = vec![
finding("a", Severity::Low, Confidence::Possible),
finding("b", Severity::Critical, Confidence::Certain),
];
let ordering = ModelOrdering {
order: vec![0, 1],
rationale: None,
};
let t = apply_model_triage(&detected, &ordering, "test-backend");
assert_eq!(t.ranked[0].severity, Severity::Low);
assert_eq!(t.ranked[0].confidence, Confidence::Possible);
assert_eq!(t.ranked[0].evidence, detected[0].evidence);
assert_eq!(t.ranked[1].severity, Severity::Critical);
}
#[test]
fn a_finding_the_model_omitted_is_kept_rather_than_dropped() {
let detected = vec![
finding("a", Severity::Low, Confidence::Certain),
finding("b.critical", Severity::Critical, Confidence::Certain),
];
let ordering = ModelOrdering {
order: vec![0],
rationale: None,
};
let t = apply_model_triage(&detected, &ordering, "test-backend");
assert_eq!(t.ranked.len(), 1);
assert_eq!(
t.unranked.len(),
1,
"an ordering that omits a finding must not remove it from the report"
);
assert_eq!(t.unranked[0].rule, "b.critical");
}
#[test]
fn a_repeated_index_is_used_once() {
let detected = vec![finding("a", Severity::Low, Confidence::Certain)];
let ordering = ModelOrdering {
order: vec![0, 0, 0],
rationale: None,
};
let t = apply_model_triage(&detected, &ordering, "test-backend");
assert_eq!(t.ranked.len(), 1);
}
#[test]
fn an_empty_ordering_leaves_everything_unranked_rather_than_losing_it() {
let detected = vec![finding("a", Severity::High, Confidence::Certain)];
let t = apply_model_triage(
&detected,
&ModelOrdering {
order: vec![],
rationale: None,
},
"test-backend",
);
assert!(t.ranked.is_empty());
assert_eq!(t.unranked.len(), 1);
}
#[test]
fn the_method_records_which_ranker_was_used() {
let detected = vec![finding("a", Severity::Low, Confidence::Certain)];
assert_eq!(rank(detected.clone()).method, Method::Deterministic);
let t = apply_model_triage(
&detected,
&ModelOrdering {
order: vec![0],
rationale: None,
},
"ollama/llama3",
);
assert_eq!(
t.method,
Method::Model {
backend: "ollama/llama3".into()
}
);
}
#[test]
fn counts_separate_heuristics_from_observations() {
let c = counts(&[
finding("a", Severity::High, Confidence::Possible),
finding("b", Severity::High, Confidence::Certain),
finding("c", Severity::Critical, Confidence::Possible),
]);
assert_eq!(c.high, 2);
assert_eq!(c.critical, 1);
assert_eq!(
c.possible_only, 2,
"'3 findings' must not be readable as '3 facts'"
);
}
#[test]
fn the_prompt_states_the_limit_it_relies_on() {
assert!(TRIAGE_PROMPT.contains("cannot add findings"));
assert!(TRIAGE_PROMPT.contains("discarded"));
}
}