secfinding 0.3.0

Universal security finding types for vulnerability scanners.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use secfinding::{Reportable, Severity};
use std::sync::Arc;

struct PolicyFinding {
    source: String,
    title: String,
    score: f64,
}

impl Reportable for PolicyFinding {
    fn scanner(&self) -> &str {
        "policy-scanner"
    }

    fn target(&self) -> &str {
        &self.source
    }

    fn severity(&self) -> Severity {
        if self.score >= 0.9 {
            Severity::Critical
        } else if self.score >= 0.7 {
            Severity::High
        } else if self.score >= 0.5 {
            Severity::Medium
        } else {
            Severity::Low
        }
    }

    fn title(&self) -> &str {
        &self.title
    }

    fn detail(&self) -> &str {
        "Policy mismatch detected by governance check"
    }

    fn confidence(&self) -> Option<f64> {
        Some(self.score)
    }

    fn tags(&self) -> &[Arc<str>] {
        &[]
    }

    fn cwe_ids(&self) -> &[Arc<str>] {
        &[]
    }

    fn cve_ids(&self) -> &[Arc<str>] {
        &[]
    }
}

fn main() {
    let f = PolicyFinding {
        source: "s3://bucket/config.yaml".into(),
        title: "Excessive privilege policy statement".into(),
        score: 0.93,
    };

    println!("scanner: {}", f.scanner());
    println!("target: {}", f.target());
    println!("severity: {}", f.severity());
    println!("rule id: {}", f.rule_id());
    println!("tags: {}", f.tags().join(", "));
    println!("{}", f.detail());
}