Enum Exploitability 

pub enum Exploitability {
    NotDefined,
    Unproven,
    ProofOfConcept,
    Functional,
    High,
}

Metric::Exploitability (E) values.

Description

This metric measures the current state of exploit techniques or code availability. Public availability of easy-to-use exploit code increases the number of potential attackers by including those who are unskilled, thereby increasing the severity of the vulnerability.

Initially, real-world exploitation may only be theoretical. Publication of proof of concept code, functional exploit code, or sufficient technical details necessary to exploit the vulnerability may follow. Furthermore, the exploit code available may progress from a proof-of-concept demonstration to exploit code that is successful in exploiting the vulnerability consistently. In severe cases, it may be delivered as the payload of a network-based worm or virus. The more easily a vulnerability can be exploited, the higher the vulnerability score.

Properties

• Metric Group: Temporal
• Documentation: CVSS v2.0 Documentation, Section 2.2.1: Exploitability (E)

Examples

Parse string as metric:

// parse string as metric
let metric: Metric = "E:H".parse()?;

// check result
assert_eq!(metric, Metric::Exploitability(Exploitability::High));

Convert metric to string:

// convert metric to string
let s = Metric::Exploitability(Exploitability::Functional).to_string();

// check result
assert_eq!(s, "E:F");

Get metric name:

// get metric name
let name = Name::from(Metric::Exploitability(Exploitability::ProofOfConcept));

// check result
assert_eq!(name, Name::Exploitability);

Variants

NotDefined

Not Defined (ND)

Assigning this value to the metric will not influence the score. It is a signal to the equation to skip this metric.

Unproven

Unproven (U)

No exploit code is available, or an exploit is entirely theoretical.

ProofOfConcept

Proof-of-Concept (POC)

Proof-of-concept exploit code or an attack demonstration that is not practical for most systems is available. The code or technique is not functional in all situations and may require substantial modification by a skilled attacker.

Functional

Functional (F)

Functional exploit code is available. The code works in most situations where the vulnerability exists.

High

High (H)

Either the vulnerability is exploitable by functional mobile autonomous code, or no exploit is required (manual trigger) and details are widely available. The code works in every situation, or is actively being delivered via a mobile autonomous agent (such as a worm or virus).

Trait Implementations

impl Clone for Exploitability

fn clone(&self) -> Exploitability

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Exploitability

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

Formats the value using the given formatter.

impl PartialEq for Exploitability

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

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

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 Copy for Exploitability

impl Eq for Exploitability

impl StructuralPartialEq for Exploitability