cvss 2.2.0

Common Vulnerability Scoring System parser/serializer
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Error types

use crate::v3;
#[cfg(feature = "v4")]
use crate::v4;
use alloc::string::String;
use core::fmt;

/// Result type with the `cvss` crate's [`Error`] type.
pub type Result<T> = core::result::Result<T, Error>;

/// Kinds of errors
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum Error {
    /// Invalid component of a CVSS metric group.
    InvalidComponent {
        /// Invalid component.
        component: String,
    },

    /// Invalid metric for CVSSv3.
    InvalidMetric {
        /// The metric that was invalid.
        metric_type: v3::metric::MetricType,

        /// The value that was provided which is invalid.
        value: String,
    },

    #[cfg(feature = "v4")]
    /// Invalid metric for CVSSv4.
    InvalidMetricV4 {
        /// The metric that was invalid.
        metric_type: v4::MetricType,

        /// The value that was provided which is invalid.
        value: String,
    },

    #[cfg(feature = "v4")]
    /// Missing metric for CVSSv4.
    MissingMandatoryMetricV4 {
        /// Prefix which is missing.
        metric_type: v4::MetricType,
    },

    #[cfg(feature = "v4")]
    /// Metric is duplicated for CVSSv4.
    DuplicateMetricV4 {
        /// Prefix which is doubled.
        metric_type: v4::MetricType,
    },

    #[cfg(feature = "v4")]
    /// Invalid nomenclature for CVSSv4.
    InvalidNomenclatureV4 {
        /// Unknown CBSSv4 nomenclature.
        nomenclature: String,
    },

    /// Invalid CVSS string prefix.
    InvalidPrefix {
        /// Prefix which is invalid.
        prefix: String,
    },

    /// Invalid severity
    InvalidSeverity {
        /// Provided name which was unrecognized.
        name: String,
    },

    /// Unknown metric name.
    UnknownMetric {
        /// Provided name which was unrecognized.
        name: String,
    },

    /// Unsupported CVSS version
    UnsupportedVersion {
        /// Provided version string.
        version: String,
    },
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::InvalidComponent { component } => {
                write!(f, "invalid CVSS metric group component: `{component}`")
            }
            Error::InvalidMetric { metric_type, value } => {
                write!(
                    f,
                    "invalid CVSSv4 {} ({}) metric: `{}`",
                    metric_type.name(),
                    metric_type.description(),
                    value
                )
            }
            #[cfg(feature = "v4")]
            Error::InvalidMetricV4 { metric_type, value } => {
                write!(
                    f,
                    "invalid CVSSv4 {} ({}) metric: `{}`",
                    metric_type.name(),
                    metric_type.description(),
                    value
                )
            }
            #[cfg(feature = "v4")]
            Error::DuplicateMetricV4 { metric_type } => {
                write!(
                    f,
                    "duplicate CVSSv4 {} ({}) metric",
                    metric_type.name(),
                    metric_type.description(),
                )
            }
            #[cfg(feature = "v4")]
            Error::MissingMandatoryMetricV4 { metric_type } => {
                write!(
                    f,
                    "missing mandatory CVSSv4 {} ({}) metric",
                    metric_type.name(),
                    metric_type.description(),
                )
            }
            #[cfg(feature = "v4")]
            Error::InvalidNomenclatureV4 { nomenclature } => {
                write!(f, "invalid CVSSv4 nomenclature: `{}`", nomenclature)
            }
            Error::InvalidPrefix { prefix } => {
                write!(f, "invalid CVSS string prefix: `{prefix}`")
            }
            Error::InvalidSeverity { name } => {
                write!(f, "invalid CVSS Qualitative Severity Rating: `{name}`")
            }
            Error::UnknownMetric { name } => write!(f, "unknown CVSS metric name: `{name}`"),
            Error::UnsupportedVersion { version } => {
                write!(f, "unsupported CVSS version: {version}")
            }
        }
    }
}

#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for Error {}