Struct Weakness

pub struct Weakness {

    pub abstraction: String,
    pub affected_resources: Vec<String>,
    pub alternate_terms: Option<AlternateTerms>,
    pub applicable_platforms: Option<ApplicablePlatforms>,
    pub background_details: Vec<String>,
    pub common_consequences: Option<Consequences>,
    pub content_history: ContentHistory,
    pub demonstrative_examples: Option<DemonstrativeExamples>,
    pub description: String,
    pub detection_methods: Option<DetectionMethods>,
    pub extended_description: Option<String>,
    pub functional_areas: Vec<String>,
    pub id: String,
    pub likelihood_of_exploit: Option<String>,
    pub mapping_notes: Option<MappingNotes>,
    pub modes_of_introduction: Option<ModesOfIntroduction>,
    pub name: String,
    pub notes: Option<Notes>,
    pub observed_examples: Option<ObservedExamples>,
    pub potential_mitigations: Option<Mitigations>,
    pub references: Option<References>,
    pub related_attack_patterns: Vec<String>,
    pub related_weaknesses: Option<RelatedWeaknesses>,
    pub status: String,
    pub structure: String,
    pub taxonomy_mappings: Option<TaxonomyMappings>,
    pub weakness_ordinalities: Option<WeaknessOrdinalities>,
}

Weakness

JSON schema

{
 "type": "object",
 "required": [
   "Abstraction",
   "ContentHistory",
   "Description",
   "ID",
   "Name",
   "Status",
   "Structure"
 ],
 "properties": {
   "Abstraction": {
     "examples": [
       "Base"
     ],
     "type": "string"
   },
   "AffectedResources": {
     "title": "AffectedResources",
     "examples": [
       [
         "System Process",
         "File or Directory"
       ]
     ],
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "AlternateTerms": {
     "$ref": "#/components/schemas/AlternateTerms"
   },
   "ApplicablePlatforms": {
     "$ref": "#/components/schemas/ApplicablePlatforms"
   },
   "BackgroundDetails": {
     "title": "BackgroundDetails",
     "examples": [
       [
         "A short detail text",
         "Another detail"
       ]
     ],
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "CommonConsequences": {
     "$ref": "#/components/schemas/Consequences"
   },
   "ContentHistory": {
     "$ref": "#/components/schemas/ContentHistory"
   },
   "DemonstrativeExamples": {
     "$ref": "#/components/schemas/DemonstrativeExamples"
   },
   "Description": {
     "examples": [
       "A short description of the weakness"
     ],
     "type": "string"
   },
   "DetectionMethods": {
     "$ref": "#/components/schemas/DetectionMethods"
   },
   "ExtendedDescription": {
     "examples": [
       "A long description of the weakness"
     ],
     "type": "string"
   },
   "FunctionalAreas": {
     "title": "FunctionalAreas",
     "examples": [
       [
         "Cryptography",
         "Logging",
         "String Processing"
       ]
     ],
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "ID": {
     "examples": [
       "79"
     ],
     "type": "string",
     "format": "integer"
   },
   "LikelihoodOfExploit": {
     "examples": [
       "High"
     ],
     "type": "string"
   },
   "MappingNotes": {
     "$ref": "#/components/schemas/MappingNotes"
   },
   "ModesOfIntroduction": {
     "$ref": "#/components/schemas/ModesOfIntroduction"
   },
   "Name": {
     "examples": [
       "Weakness Title"
     ],
     "type": "string"
   },
   "Notes": {
     "$ref": "#/components/schemas/Notes"
   },
   "ObservedExamples": {
     "$ref": "#/components/schemas/ObservedExamples"
   },
   "PotentialMitigations": {
     "$ref": "#/components/schemas/Mitigations"
   },
   "References": {
     "$ref": "#/components/schemas/References"
   },
   "RelatedAttackPatterns": {
     "title": "RelatedAttackPatterns",
     "examples": [
       [
         "103",
         "23"
       ]
     ],
     "type": "array",
     "items": {
       "type": "string",
       "format": "integer"
     }
   },
   "RelatedWeaknesses": {
     "$ref": "#/components/schemas/RelatedWeaknesses"
   },
   "Status": {
     "examples": [
       "Stable"
     ],
     "type": "string"
   },
   "Structure": {
     "examples": [
       "Simple"
     ],
     "type": "string"
   },
   "TaxonomyMappings": {
     "$ref": "#/components/schemas/TaxonomyMappings"
   },
   "WeaknessOrdinalities": {
     "$ref": "#/components/schemas/WeaknessOrdinalities"
   }
 },
 "additionalProperties": false
}

Fields

abstraction: String

affected_resources: Vec<String>

alternate_terms: Option<AlternateTerms>

applicable_platforms: Option<ApplicablePlatforms>

background_details: Vec<String>

common_consequences: Option<Consequences>

content_history: ContentHistory

demonstrative_examples: Option<DemonstrativeExamples>

description: String

detection_methods: Option<DetectionMethods>

extended_description: Option<String>

functional_areas: Vec<String>

id: String

likelihood_of_exploit: Option<String>

mapping_notes: Option<MappingNotes>

modes_of_introduction: Option<ModesOfIntroduction>

name: String

notes: Option<Notes>

observed_examples: Option<ObservedExamples>

potential_mitigations: Option<Mitigations>

references: Option<References>

related_attack_patterns: Vec<String>

related_weaknesses: Option<RelatedWeaknesses>

status: String

structure: String

taxonomy_mappings: Option<TaxonomyMappings>

weakness_ordinalities: Option<WeaknessOrdinalities>

Trait Implementations

impl Clone for Weakness

fn clone(&self) -> Weakness

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Weakness

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Weakness

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Weakness> for Weakness

fn from(value: &Weakness) -> Self

Converts to this type from the input type.

impl Serialize for Weakness

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

where __S: Serializer,

Serialize this value into the given Serde serializer.