Struct V3Vector

pub struct V3Vector {

    pub minor_version: MinorVersion,
    pub attack_vector: AttackVector,
    pub attack_complexity: AttackComplexity,
    pub privileges_required: PrivilegesRequired,
    pub user_interaction: UserInteraction,
    pub scope: Scope,
    pub confidentiality: Confidentiality,
    pub integrity: Integrity,
    pub availability: Availability,
    pub exploit_code_maturity: ExploitCodeMaturity,
    pub remediation_level: RemediationLevel,
    pub report_confidence: ReportConfidence,
    pub confidentiality_requirement: ConfidentialityRequirement,
    pub integrity_requirement: IntegrityRequirement,
    pub availability_requirement: AvailabilityRequirement,
    pub modified_attack_vector: ModifiedAttackVector,
    pub modified_attack_complexity: ModifiedAttackComplexity,
    pub modified_privileges_required: ModifiedPrivilegesRequired,
    pub modified_user_interaction: ModifiedUserInteraction,
    pub modified_scope: ModifiedScope,
    pub modified_confidentiality: ModifiedConfidentiality,
    pub modified_integrity: ModifiedIntegrity,
    pub modified_availability: ModifiedAvailability,
}

CVSS vector version 3.0/3.1

use cvssrust::v3::V3Vector;
use cvssrust::CVSSScore;
use std::str::FromStr;
 
let cvss_str = "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N/E:P/RL:W/RC:C";
let cvss = V3Vector::from_str(cvss_str).unwrap();
 
assert_eq!(cvss.to_string(), String::from(cvss_str));
assert_eq!(cvss.base_score().value(), 6.1);
assert_eq!(cvss.base_score().severity().to_string(), "Medium");
assert_eq!(cvss.temporal_score().value(), 5.6);

Fields

minor_version: MinorVersion

attack_vector: AttackVector

attack_complexity: AttackComplexity

privileges_required: PrivilegesRequired

user_interaction: UserInteraction

scope: Scope

confidentiality: Confidentiality

integrity: Integrity

availability: Availability

exploit_code_maturity: ExploitCodeMaturity

remediation_level: RemediationLevel

report_confidence: ReportConfidence

confidentiality_requirement: ConfidentialityRequirement

integrity_requirement: IntegrityRequirement

availability_requirement: AvailabilityRequirement

modified_attack_vector: ModifiedAttackVector

modified_attack_complexity: ModifiedAttackComplexity

modified_privileges_required: ModifiedPrivilegesRequired

modified_user_interaction: ModifiedUserInteraction

modified_scope: ModifiedScope

modified_confidentiality: ModifiedConfidentiality

modified_integrity: ModifiedIntegrity

modified_availability: ModifiedAvailability

Implementations

impl V3Vector

pub fn modified_impact_subscore(&self) -> Score

Calculate Modified Impact SubScore

pub fn modified_impact_score(&self) -> Score

Calculate Modified Impact Score

Examples found in repository

examples/calc.rs (line 24)

fn main() {
    let vector = env::args().skip(1).next().expect("Provide CVSS vector");

    match CVSS::parse(vector.as_str()) {
        Ok(CVSS::V3(cvss)) => {
            println!("CVSS v3 vector: {}", cvss.to_string());
            println!("CVSS Base score: {}", cvss.base_score().value());
            println!("CVSS Base severity: {}", cvss.base_score().severity());
            println!("Impact Subscore: {}", cvss.impact_score().value());
            println!(
                "Exploitability Subscore: {}",
                cvss.expoitability_score().value()
            );
            println!("CVSS Temporal score: {}", cvss.temporal_score().value());
            println!(
                "CVSS Environmental score: {}",
                cvss.environmental_score().value()
            );
            println!(
                "Modified Impact Subscore: {}",
                cvss.modified_impact_score().value()
            );
            println!(
                "Modified Exploitability Subscore: {}",
                cvss.modified_exploitability_score().value()
            );
        }
        Ok(CVSS::V2(cvss)) => {
            println!("CVSS v2 vector: {}", cvss.to_string());
            println!("CVSS Base score: {}", cvss.base_score().value());
            println!("CVSS Base severity: {}", cvss.base_score().severity());
            println!("Impact Subscore: {}", cvss.impact_score().value());
            println!(
                "Exploitability Subscore: {}",
                cvss.expoitability_score().value()
            );
            println!("CVSS Temporal score: {}", cvss.temporal_score().value());
            println!(
                "CVSS Environmental score: {}",
                cvss.environmental_score().value()
            );
        }
        _ => println!("Could not parse the CVSS vector"),
    }
}

pub fn modified_exploitability_score(&self) -> Score

Calculate Modified Exploitability Score

Examples found in repository

examples/calc.rs (line 28)

fn main() {
    let vector = env::args().skip(1).next().expect("Provide CVSS vector");

    match CVSS::parse(vector.as_str()) {
        Ok(CVSS::V3(cvss)) => {
            println!("CVSS v3 vector: {}", cvss.to_string());
            println!("CVSS Base score: {}", cvss.base_score().value());
            println!("CVSS Base severity: {}", cvss.base_score().severity());
            println!("Impact Subscore: {}", cvss.impact_score().value());
            println!(
                "Exploitability Subscore: {}",
                cvss.expoitability_score().value()
            );
            println!("CVSS Temporal score: {}", cvss.temporal_score().value());
            println!(
                "CVSS Environmental score: {}",
                cvss.environmental_score().value()
            );
            println!(
                "Modified Impact Subscore: {}",
                cvss.modified_impact_score().value()
            );
            println!(
                "Modified Exploitability Subscore: {}",
                cvss.modified_exploitability_score().value()
            );
        }
        Ok(CVSS::V2(cvss)) => {
            println!("CVSS v2 vector: {}", cvss.to_string());
            println!("CVSS Base score: {}", cvss.base_score().value());
            println!("CVSS Base severity: {}", cvss.base_score().severity());
            println!("Impact Subscore: {}", cvss.impact_score().value());
            println!(
                "Exploitability Subscore: {}",
                cvss.expoitability_score().value()
            );
            println!("CVSS Temporal score: {}", cvss.temporal_score().value());
            println!(
                "CVSS Environmental score: {}",
                cvss.environmental_score().value()
            );
        }
        _ => println!("Could not parse the CVSS vector"),
    }
}

impl V3Vector

pub fn new( attack_vector: AttackVector, attack_complexity: AttackComplexity, privileges_required: PrivilegesRequired, user_interaction: UserInteraction, scope: Scope, confidentiality: Confidentiality, integrity: Integrity, availability: Availability, ) -> Self

Constructor

pub fn extend_with_temporal( &mut self, temporal_str: &str, ) -> Result<(), ParseError>

Parse the temporal fields in temporal_str, adding them to the V3Vector.

use cvssrust::v3::V3Vector;
use cvssrust::v3::temporal::{ExploitCodeMaturity, RemediationLevel, ReportConfidence};
use std::str::FromStr;

let cvss_base = "CVSS:3.0/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N";
let cvss_temporal = "E:P/RL:W/RC:C";

let mut cvss = V3Vector::from_str(cvss_base).unwrap();
assert_eq!(cvss.exploit_code_maturity, ExploitCodeMaturity::NotDefined);
assert_eq!(cvss.remediation_level, RemediationLevel::NotDefined);
assert_eq!(cvss.report_confidence, ReportConfidence::NotDefined);

cvss.extend_with_temporal(cvss_temporal).unwrap();
assert_eq!(cvss.exploit_code_maturity, ExploitCodeMaturity::ProofOfConcept);
assert_eq!(cvss.remediation_level, RemediationLevel::Workaround);
assert_eq!(cvss.report_confidence, ReportConfidence::Confirmed);

Trait Implementations

impl CVSSScore for V3Vector

fn temporal_score(&self) -> Score

TemporalScore = Roundup ( BaseScore × ExploitCodeMaturity × RemediationLevel × ReportConfidence)

fn impact_score(&self) -> Score

Calculate Impact Sub Score

fn expoitability_score(&self) -> Score

Calculate Exploitability Score

fn base_score(&self) -> Score

Calculate CVSS Base Score

fn environmental_score(&self) -> Score

Calculate CVSS Environmental Score

impl Clone for V3Vector

fn clone(&self) -> V3Vector

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for V3Vector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for V3Vector

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for V3Vector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for V3Vector

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(cvss_str: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for V3Vector

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for V3Vector

fn eq(&self, other: &V3Vector) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for V3Vector

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for V3Vector

impl Eq for V3Vector

impl StructuralPartialEq for V3Vector