1use crate::length::CodeLength;
4use crate::score::Score;
5use crate::taxonomy::{Cwe, Domain, Technique};
6
7const EXPLORATION_DIVISOR: f64 = 20.0;
9
10#[derive(Debug, Clone, PartialEq, Eq)]
12#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13pub struct CodeAnalysis {
14 pub readability: Score,
16 pub complexity: Score,
18 pub length: CodeLength,
20 pub attack_surface: Score,
22}
23
24impl CodeAnalysis {
25 #[must_use]
27 pub fn exploration(&self) -> Score {
28 let breadth = self.length.score().get() + self.attack_surface.get();
29 Score::clamped(self.readability.get() * breadth / EXPLORATION_DIVISOR)
30 }
31
32 #[must_use]
34 pub fn total(&self) -> Score {
35 Score::clamped(self.exploration().get() / 3.0 + self.complexity.get() * 2.0 / 3.0).rounded()
36 }
37}
38
39#[derive(Debug, Clone, PartialEq, Eq)]
41#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
42pub struct VulnerabilityDiscovery {
43 pub cwes: Vec<Cwe>,
46 pub complexity: Score,
48 pub locality: Score,
50}
51
52impl VulnerabilityDiscovery {
53 #[must_use]
55 pub fn new(cwes: impl Into<Vec<Cwe>>, complexity: Score, locality: Score) -> Self {
56 Self {
57 cwes: cwes.into(),
58 complexity,
59 locality,
60 }
61 }
62
63 #[must_use]
65 pub fn with_cwe_count(count: usize, complexity: Score, locality: Score) -> Self {
66 Self::new(vec![Cwe::UNSPECIFIED; count], complexity, locality)
67 }
68
69 #[must_use]
71 pub fn vulnerability_complexity(&self) -> Score {
72 #[allow(clippy::cast_precision_loss)]
73 let count = self.cwes.len() as f64;
74 Score::clamped(self.complexity.get() + count)
75 }
76
77 #[must_use]
79 pub fn total(&self) -> Score {
80 Score::clamped(
81 self.vulnerability_complexity().get() * 4.0 / 5.0 + self.locality.get() / 5.0,
82 )
83 .rounded()
84 }
85}
86
87#[derive(Debug, Clone, PartialEq, Eq)]
89#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
90pub struct ExploitDevelopment {
91 pub complexity: Score,
93 pub techniques: Vec<Technique>,
95 pub harness: Score,
97}
98
99impl ExploitDevelopment {
100 #[must_use]
102 pub fn new(complexity: Score, techniques: impl Into<Vec<Technique>>, harness: Score) -> Self {
103 Self {
104 complexity,
105 techniques: techniques.into(),
106 harness,
107 }
108 }
109
110 #[must_use]
113 pub fn with_technique_count(complexity: Score, count: usize, harness: Score) -> Self {
114 Self::new(complexity, vec![Technique::Unspecified; count], harness)
115 }
116
117 #[must_use]
123 pub fn exploit_complexity(&self) -> Score {
124 #[allow(clippy::cast_precision_loss)]
125 let count = self.techniques.len() as f64;
126 Score::clamped(self.complexity.get() + count)
127 }
128
129 #[must_use]
131 pub fn total(&self) -> Score {
132 self.exploit_complexity().max(self.harness).rounded()
133 }
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
138#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
139pub struct DomainRequirement {
140 pub domain: Domain,
142 pub level: Score,
144 pub detail: Option<String>,
146}
147
148impl DomainRequirement {
149 #[must_use]
151 pub fn new(domain: Domain, level: Score) -> Self {
152 Self {
153 domain,
154 level,
155 detail: None,
156 }
157 }
158
159 #[must_use]
161 pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
162 self.detail = Some(detail.into());
163 self
164 }
165}
166
167#[derive(Debug, Clone, Default, PartialEq, Eq)]
169#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
170#[cfg_attr(feature = "serde", serde(transparent))]
171pub struct ExpertKnowledge {
172 pub requirements: Vec<DomainRequirement>,
174}
175
176impl ExpertKnowledge {
177 #[must_use]
179 pub fn none() -> Self {
180 Self::default()
181 }
182
183 #[must_use]
185 pub fn new(requirements: impl Into<Vec<DomainRequirement>>) -> Self {
186 Self {
187 requirements: requirements.into(),
188 }
189 }
190
191 #[must_use]
193 pub fn total(&self) -> Score {
194 self.requirements
195 .iter()
196 .map(|requirement| requirement.level)
197 .max()
198 .unwrap_or(Score::ZERO)
199 }
200}