use crate::length::CodeLength;
use crate::score::Score;
use crate::taxonomy::{Cwe, Domain, Technique};
const EXPLORATION_DIVISOR: f64 = 20.0;
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CodeAnalysis {
pub readability: Score,
pub complexity: Score,
pub length: CodeLength,
pub attack_surface: Score,
}
impl CodeAnalysis {
#[must_use]
pub fn exploration(&self) -> Score {
let breadth = self.length.score().get() + self.attack_surface.get();
Score::clamped(self.readability.get() * breadth / EXPLORATION_DIVISOR)
}
#[must_use]
pub fn total(&self) -> Score {
Score::clamped(self.exploration().get() / 3.0 + self.complexity.get() * 2.0 / 3.0).rounded()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VulnerabilityDiscovery {
pub cwes: Vec<Cwe>,
pub complexity: Score,
pub locality: Score,
}
impl VulnerabilityDiscovery {
#[must_use]
pub fn new(cwes: impl Into<Vec<Cwe>>, complexity: Score, locality: Score) -> Self {
Self {
cwes: cwes.into(),
complexity,
locality,
}
}
#[must_use]
pub fn with_cwe_count(count: usize, complexity: Score, locality: Score) -> Self {
Self::new(vec![Cwe::UNSPECIFIED; count], complexity, locality)
}
#[must_use]
pub fn vulnerability_complexity(&self) -> Score {
#[allow(clippy::cast_precision_loss)]
let count = self.cwes.len() as f64;
Score::clamped(self.complexity.get() + count)
}
#[must_use]
pub fn total(&self) -> Score {
Score::clamped(
self.vulnerability_complexity().get() * 4.0 / 5.0 + self.locality.get() / 5.0,
)
.rounded()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ExploitDevelopment {
pub complexity: Score,
pub techniques: Vec<Technique>,
pub harness: Score,
}
impl ExploitDevelopment {
#[must_use]
pub fn new(complexity: Score, techniques: impl Into<Vec<Technique>>, harness: Score) -> Self {
Self {
complexity,
techniques: techniques.into(),
harness,
}
}
#[must_use]
pub fn with_technique_count(complexity: Score, count: usize, harness: Score) -> Self {
Self::new(complexity, vec![Technique::Unspecified; count], harness)
}
#[must_use]
pub fn exploit_complexity(&self) -> Score {
#[allow(clippy::cast_precision_loss)]
let count = self.techniques.len() as f64;
Score::clamped(self.complexity.get() + count)
}
#[must_use]
pub fn total(&self) -> Score {
self.exploit_complexity().max(self.harness).rounded()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DomainRequirement {
pub domain: Domain,
pub level: Score,
pub detail: Option<String>,
}
impl DomainRequirement {
#[must_use]
pub fn new(domain: Domain, level: Score) -> Self {
Self {
domain,
level,
detail: None,
}
}
#[must_use]
pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
self.detail = Some(detail.into());
self
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct ExpertKnowledge {
pub requirements: Vec<DomainRequirement>,
}
impl ExpertKnowledge {
#[must_use]
pub fn none() -> Self {
Self::default()
}
#[must_use]
pub fn new(requirements: impl Into<Vec<DomainRequirement>>) -> Self {
Self {
requirements: requirements.into(),
}
}
#[must_use]
pub fn total(&self) -> Score {
self.requirements
.iter()
.map(|requirement| requirement.level)
.max()
.unwrap_or(Score::ZERO)
}
}