feat: add test 6.1.31

csaf-rs/src/csaf2_0/csaf_implementations.rs

@@ -8,18 +8,18 @@ use crate::csaf_traits::{
 };
 use crate::csaf2_1::ssvc_dp_selection_list::SelectionList;
 use crate::schema::csaf2_0::schema::{
-    Branch, CategoryOfPublisher, CategoryOfReference, CategoryOfTheRemediation, CategoryOfTheThreat,
-    CommonSecurityAdvisoryFramework, CryptographicHashes, CsafVersion as CsafVersion20, DocumentGenerator,
-    DocumentLevelMetaData, DocumentStatus, FileHash, Flag, FullProductNameT, HelperToIdentifyTheProduct, Id,
-    Involvement, LabelOfTheFlag, LabelOfTlp, Note, NoteCategory, PartyCategory, ProductGroup, ProductStatus,
-    ProductTree, Publisher, Reference, Relationship, Remediation, Revision, RulesForSharingDocument, Score, Threat,
-    Tracking, TrafficLightProtocolTlp, Vulnerability,
+    Branch, CategoryOfPublisher, CategoryOfReference, CategoryOfTheBranch, CategoryOfTheRemediation,
+    CategoryOfTheThreat, CommonSecurityAdvisoryFramework, CryptographicHashes, CsafVersion as CsafVersion20,
+    DocumentGenerator, DocumentLevelMetaData, DocumentStatus, FileHash, Flag, FullProductNameT,
+    HelperToIdentifyTheProduct, Id, Involvement, LabelOfTheFlag, LabelOfTlp, Note, NoteCategory, PartyCategory,
+    ProductGroup, ProductStatus, ProductTree, Publisher, Reference, Relationship, Remediation, Revision,
+    RulesForSharingDocument, Score, Threat, Tracking, TrafficLightProtocolTlp, Vulnerability,
 };
 use crate::schema::csaf2_1::schema::{
     CategoryOfPublisher as CategoryOfPublisher21, CategoryOfReference as CategoryOfReference21,
-    CategoryOfTheRemediation as Remediation21, CategoryOfTheThreat as CategoryOfTheThreat21,
-    DocumentStatus as Status21, Epss, LabelOfTheFlag as LabelOfTheFlag21, LabelOfTlp as Tlp21,
-    NoteCategory as NoteCategory21, PartyCategory as PartyCategory21,
+    CategoryOfTheBranch as CategoryOfTheBranch21, CategoryOfTheRemediation as Remediation21,
+    CategoryOfTheThreat as CategoryOfTheThreat21, DocumentStatus as Status21, Epss, LabelOfTheFlag as LabelOfTheFlag21,
+    LabelOfTlp as Tlp21, NoteCategory as NoteCategory21, PartyCategory as PartyCategory21,
 };
 use crate::validation::ValidationError;
 use serde::de::Error;
@@ -592,6 +592,27 @@ impl BranchTrait<FullProductNameT> for Branch {
         self.branches.as_deref()
     }
 
+    fn get_category(&self) -> &CategoryOfTheBranch21 {
+        match self.category {
+            CategoryOfTheBranch::Architecture => &CategoryOfTheBranch21::Architecture,
+            CategoryOfTheBranch::HostName => &CategoryOfTheBranch21::HostName,
+            CategoryOfTheBranch::Language => &CategoryOfTheBranch21::Language,
+            CategoryOfTheBranch::Legacy => &CategoryOfTheBranch21::Legacy,
+            CategoryOfTheBranch::PatchLevel => &CategoryOfTheBranch21::PatchLevel,
+            CategoryOfTheBranch::ProductFamily => &CategoryOfTheBranch21::ProductFamily,
+            CategoryOfTheBranch::ProductName => &CategoryOfTheBranch21::ProductName,
+            CategoryOfTheBranch::ProductVersion => &CategoryOfTheBranch21::ProductVersion,
+            CategoryOfTheBranch::ProductVersionRange => &CategoryOfTheBranch21::ProductVersionRange,
+            CategoryOfTheBranch::ServicePack => &CategoryOfTheBranch21::ServicePack,
+            CategoryOfTheBranch::Specification => &CategoryOfTheBranch21::Specification,
+            CategoryOfTheBranch::Vendor => &CategoryOfTheBranch21::Vendor,
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        self.name.deref()
+    }
+
     fn get_product(&self) -> &Option<FullProductNameT> {
         &self.product
     }
@@ -627,6 +648,10 @@ impl ProductTrait for FullProductNameT {
         self.product_id.deref()
     }
 
+    fn get_name(&self) -> &str {
+        self.name.deref()
+    }
+
     fn get_product_identification_helper(&self) -> &Option<Self::ProductIdentificationHelperType> {
         &self.product_identification_helper
     }

csaf-rs/src/csaf2_1/csaf_implementations.rs

@@ -8,12 +8,13 @@ use crate::csaf_traits::{
 };
 use crate::csaf2_1::ssvc_dp_selection_list::SelectionList;
 use crate::schema::csaf2_1::schema::{
-    Branch, CategoryOfPublisher, CategoryOfReference, CategoryOfTheRemediation, CategoryOfTheThreat,
-    CommonSecurityAdvisoryFramework, Content, CryptographicHashes, CsafVersion as CsafVersion21, DocumentGenerator,
-    DocumentLevelMetaData, DocumentStatus, Epss, FileHash, FirstKnownExploitationDate, Flag, FullProductNameT,
-    HelperToIdentifyTheProduct, Id, Involvement, LabelOfTheFlag, LabelOfTlp, Metric, Note, NoteCategory, PartyCategory,
-    ProductGroup, ProductStatus, ProductTree, Publisher, Reference, Relationship, Remediation, Revision,
-    RulesForDocumentSharing, SharingGroup, Threat, Tracking, TrafficLightProtocolTlp, Vulnerability,
+    Branch, CategoryOfPublisher, CategoryOfReference, CategoryOfTheBranch, CategoryOfTheRemediation,
+    CategoryOfTheThreat, CommonSecurityAdvisoryFramework, Content, CryptographicHashes, CsafVersion as CsafVersion21,
+    DocumentGenerator, DocumentLevelMetaData, DocumentStatus, Epss, FileHash, FirstKnownExploitationDate, Flag,
+    FullProductNameT, HelperToIdentifyTheProduct, Id, Involvement, LabelOfTheFlag, LabelOfTlp, Metric, Note,
+    NoteCategory, PartyCategory, ProductGroup, ProductStatus, ProductTree, Publisher, Reference, Relationship,
+    Remediation, Revision, RulesForDocumentSharing, SharingGroup, Threat, Tracking, TrafficLightProtocolTlp,
+    Vulnerability,
 };
 use crate::validation::ValidationError;
 use serde_json::{Map, Value};
@@ -502,6 +503,14 @@ impl BranchTrait<FullProductNameT> for Branch {
         self.branches.as_deref()
     }
 
+    fn get_category(&self) -> &CategoryOfTheBranch {
+        &self.category
+    }
+
+    fn get_name(&self) -> &str {
+        self.name.deref()
+    }
+
     fn get_product(&self) -> &Option<FullProductNameT> {
         &self.product
     }
@@ -538,6 +547,10 @@ impl ProductTrait for FullProductNameT {
         self.product_id.deref()
     }
 
+    fn get_name(&self) -> &str {
+        self.name.deref()
+    }
+
     fn get_product_identification_helper(&self) -> &Option<Self::ProductIdentificationHelperType> {
         &self.product_identification_helper
     }

csaf-rs/src/csaf_traits.rs

@@ -1,6 +1,6 @@
 use crate::schema::csaf2_1::schema::{
-    CategoryOfPublisher, CategoryOfReference, CategoryOfTheRemediation, CategoryOfTheThreat, DocumentStatus, Epss,
-    LabelOfTheFlag, LabelOfTlp, NoteCategory, PartyCategory,
+    CategoryOfPublisher, CategoryOfReference, CategoryOfTheBranch, CategoryOfTheRemediation, CategoryOfTheThreat,
+    DocumentStatus, Epss, LabelOfTheFlag, LabelOfTlp, NoteCategory, PartyCategory,
 };
 
 use crate::csaf2_1::ssvc_dp_selection_list::SelectionList;
@@ -1062,6 +1062,10 @@ pub trait BranchTrait<FPN: ProductTrait>: Sized {
     /// Returns an optional reference to the child branches of this branch.
     fn get_branches(&self) -> Option<&Vec<Self>>;
 
+    fn get_category(&self) -> &CategoryOfTheBranch;
+
+    fn get_name(&self) -> &str;
+
     /// Retrieves the full product name associated with this branch, if available.
     fn get_product(&self) -> &Option<FPN>;
 
@@ -1150,6 +1154,9 @@ pub trait ProductTrait {
     /// Returns the product ID from the full product name.
     fn get_product_id(&self) -> &String;
 
+    /// Returns the textual description of the product
+    fn get_name(&self) -> &str;
+
     /// Returns the product identification helper associated with the full product name.
     fn get_product_identification_helper(&self) -> &Option<Self::ProductIdentificationHelperType>;
 }

csaf-rs/src/validations/mod.rs

@@ -39,7 +39,7 @@ pub mod test_6_1_27_11;
 pub mod test_6_1_28;
 pub mod test_6_1_29;
 pub mod test_6_1_30;
-// pub mod test_6_1_31;
+pub mod test_6_1_31;
 pub mod test_6_1_32;
 pub mod test_6_1_33;
 pub mod test_6_1_34;

csaf-rs/src/validations/test_6_1_31.rs

@@ -0,0 +1,161 @@
+use crate::csaf_traits::{BranchTrait, CsafTrait, ProductTreeTrait};
+use crate::schema::csaf2_1::schema::CategoryOfTheBranch;
+use crate::validation::ValidationError;
+
+fn create_forbidden_strings_in_version_error(
+    product_name: &str,
+    forbidden_substring: &str,
+    product_path: &str,
+) -> ValidationError {
+    ValidationError {
+        message: format!(
+            "Product version '{}' contains forbidden substring '{}'",
+            product_name, forbidden_substring
+        ),
+        instance_path: format!("{}/name", product_path),
+    }
+}
+
+/// This order implicitly ensures that <= will be found before <, which will also match.
+const FORBIDDEN_SUBSTRINGS: &[&str] = &["<=", "<", ">=", ">"];
+const FORBIDDEN_KEYWORDS: &[&str] = &["after", "all", "before", "earlier", "later", "prior", "versions"];
+
+/// 6.1.31 Version Range in Product Version
+/// All branches with type `product_version` in the product tree must not contain any of the substrings
+/// `<, <=, >, >=, after, all, before, earlier, later, prior, versions` in their branch `name`.
+/// `<=` and `>=` are prioritized before `<` and `>` respectively. This only returns the first error,
+/// i.e. `all versions before versions 4.x` would only throw an error for the `all` substring.
+pub fn test_6_1_31_version_range_in_product_version_branch_name(
+    doc: &impl CsafTrait,
+) -> Result<(), Vec<ValidationError>> {
+    let mut errors: Option<Vec<ValidationError>> = None;
+    if let Some(product_tree) = doc.get_product_tree().as_ref() {
+        if let Some(branches) = product_tree.get_branches().as_ref() {
+            for (i, branch) in branches.iter().enumerate() {
+                branch.visit_branches_rec(&format!("/product_tree/branches/{}", i), &mut |branch, path| {
+                    if branch.get_category() == &CategoryOfTheBranch::ProductVersion {
+                        let branch_name = branch.get_name().to_lowercase();
+                        for forbidden in FORBIDDEN_SUBSTRINGS {
+                            if branch_name.contains(forbidden) {
+                                errors
+                                    .get_or_insert_with(Vec::new)
+                                    .push(create_forbidden_strings_in_version_error(
+                                        branch.get_name(),
+                                        forbidden,
+                                        path,
+                                    ));
+                                break;
+                            }
+                        }
+                        let product_name_tokenized = branch_name.split_whitespace().collect::<Vec<&str>>();
+                        for token in product_name_tokenized {
+                            if FORBIDDEN_KEYWORDS.contains(&token) {
+                                errors
+                                    .get_or_insert_with(Vec::new)
+                                    .push(create_forbidden_strings_in_version_error(
+                                        branch.get_name(),
+                                        token,
+                                        path,
+                                    ));
+                                break;
+                            }
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    errors.map_or(Ok(()), Err)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_helper::{run_csaf20_tests, run_csaf21_tests};
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_test_6_1_31() {
+        let errors = HashMap::from([
+            (
+                "01",
+                vec![create_forbidden_strings_in_version_error(
+                    "prior to 4.2",
+                    "prior",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "02",
+                vec![create_forbidden_strings_in_version_error(
+                    "<4.2",
+                    "<",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "03",
+                vec![create_forbidden_strings_in_version_error(
+                    "<=4.1",
+                    "<=",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "04",
+                vec![create_forbidden_strings_in_version_error(
+                    "<= 4.1",
+                    "<=",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "05",
+                vec![create_forbidden_strings_in_version_error(
+                    "4.1 and earlier",
+                    "earlier",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "06",
+                vec![create_forbidden_strings_in_version_error(
+                    "all",
+                    "all",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "07",
+                vec![create_forbidden_strings_in_version_error(
+                    "before 4.2",
+                    "before",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "08",
+                vec![create_forbidden_strings_in_version_error(
+                    "4.2 and later",
+                    "later",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+            (
+                "09",
+                vec![create_forbidden_strings_in_version_error(
+                    "3.X versions",
+                    "versions",
+                    "/product_tree/branches/0/branches/0/branches/0",
+                )],
+            ),
+        ]);
+        run_csaf20_tests(
+            "31",
+            test_6_1_31_version_range_in_product_version_branch_name,
+            errors.clone(),
+        );
+        run_csaf21_tests("31", test_6_1_31_version_range_in_product_version_branch_name, errors);
+    }
+}