support cdx 1.6

src/CycloneDX.Core/BomUtils.cs

@@ -17,9 +17,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
 using CycloneDX.Models;
 using CycloneDX.Models.Vulnerabilities;
+using static CycloneDX.Models.EvidenceIdentity;
 
 namespace CycloneDX
 {
@@ -69,7 +71,8 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                 bomCopy.SerialNumber = null;
                 bomCopy.ExternalReferences = null;
 
-                EnumerateAllComponents(bomCopy, (component) => {
+                EnumerateAllComponents(bomCopy, (component) =>
+                {
                     component.BomRef = null;
                     component.Pedigree = null;
                     component.ExternalReferences = null;
@@ -82,7 +85,8 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                 bomCopy.Dependencies = null;
                 bomCopy.Services = null;
 
-                EnumerateAllComponents(bomCopy, (component) => {
+                EnumerateAllComponents(bomCopy, (component) =>
+                {
                     component.Author = null;
                     component.MimeType = null;
                     component.Supplier = null;
@@ -103,7 +107,8 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                     bomCopy.Metadata.Licenses = null;
                     bomCopy.Metadata.Properties = null;
                 }
-                EnumerateAllComponents(bomCopy, (component) => {
+                EnumerateAllComponents(bomCopy, (component) =>
+                {
                     component.Properties = null;
                     component.Evidence = null;
                     if (component.ExternalReferences != null)
@@ -114,7 +119,8 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                         }
                     }
                 });
-                EnumerateAllServices(bomCopy, (service) => {
+                EnumerateAllServices(bomCopy, (service) =>
+                {
                     service.Properties = null;
                     if (service.ExternalReferences != null)
                     {
@@ -128,14 +134,16 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
 
             if (bomCopy.SpecVersion < SpecificationVersion.v1_4)
             {
-                EnumerateAllComponents(bomCopy, (component) => {
+                EnumerateAllComponents(bomCopy, (component) =>
+                {
                     component.ReleaseNotes = null;
                     if (component.Version == null)
                     {
                         component.Version = "0.0.0";
                     }
                 });
-                EnumerateAllServices(bomCopy, (service) => {
+                EnumerateAllServices(bomCopy, (service) =>
+                {
                     service.ReleaseNotes = null;
                 });
                 bomCopy.Vulnerabilities = null;
@@ -157,7 +165,7 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                         composition.Vulnerabilities = null;
                     }
                 }
-                
+
                 EnumerateAllToolChoices(bomCopy, (toolchoice) =>
                 {
                     toolchoice.Components = null;
@@ -170,7 +178,7 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                     component.Data = null;
                     if ((int)component.Type > 8) component.Type = Component.Classification.Library;
                 });
-                
+
                 EnumerateAllServices(bomCopy, (service) =>
                 {
                     service.TrustZone = null;
@@ -186,7 +194,7 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                         }
                     }
                 });
-                
+
                 EnumerateAllVulnerabilities(bomCopy, (vulnerability) =>
                 {
                     vulnerability.Rejected = null;
@@ -215,19 +223,19 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                         }
                     }
                 });
-                
+
                 EnumerateAllEvidence(bomCopy, (evidence) =>
                 {
                     evidence.Identity = null;
                     evidence.Occurrences = null;
                     evidence.Callstack = null;
                 });
-                
+
                 EnumerateAllLicenseChoices(bomCopy, (licenseChoice) =>
                 {
                     licenseChoice.BomRef = null;
                 });
-                
+
                 EnumerateAllLicenses(bomCopy, (license) =>
                 {
                     license.BomRef = null;
@@ -246,6 +254,79 @@ internal static Bom CopyBomAndDowngrade(Bom bom)
                 });
             }
 
+            if (bomCopy.SpecVersion < SpecificationVersion.v1_6)
+            {
+                bomCopy.Declarations = null;
+                bomCopy.Definitions = null;
+
+                EnumerateAllComponents(bomCopy, (component) =>
+                {
+                    component.CryptoProperties = null;
+                    if (component.Type == Component.Classification.Cryptographic_Asset)
+                    {
+                        component.Type = Component.Classification.Library;
+                    }
+                    component.Tags = null;
+                    component.OmniborId = null;
+                    component.Swhid = null;
+                    component.Authors = null;
+                    component.Manufacturer = null;
+
+                    if (component.ModelCard?.Considerations != null)
+                    {
+                        component.ModelCard.Considerations.EnvironmentalConsiderations = null;
+                    }
+                });
+
+                EnumerateAllOrganizationalEntity(bomCopy, (oe) =>
+                {
+                    oe.Address = null;
+                });
+
+                EnumerateAllServices(bomCopy, (service) =>
+                {
+                    service.Tags = null;
+                });
+
+                if (bomCopy.Metadata != null)
+                {
+                    bomCopy.Metadata.Manufacturer = null;
+                }
+
+                EnumerateAllDependencies(bomCopy, (dependency) =>
+                {
+                    dependency.Provides = null;
+                });
+
+                EnumerateAllEvidence(bomCopy, (evidence) =>
+                {
+                    if (evidence?.Identity?.Count > 1)
+                    {
+                        evidence.Identity.RemoveRange(1, evidence.Identity.Count - 1);
+                    }
+                    if (evidence.Identity?.Count == 1 &&
+                        (evidence.Identity[0].Field == EvidenceFieldType.OmniborId
+                        || evidence.Identity[0].Field == EvidenceFieldType.Swhid))
+                    {
+                        evidence.Identity.Clear();
+                    }
+                    if (evidence.Identity?.Count == 1)
+                    {
+                        evidence.Identity[0].ConcludedValue = null;
+                    }
+                });
+
+                EnumerateAllLicenseChoices(bomCopy, (licenseChoice) =>
+                {
+                    if (licenseChoice.License != null)
+                    {
+                        licenseChoice.License.Acknowledgement = null;
+                    }
+                    licenseChoice.Acknowledgement = null;
+                });
+
+            }
+
             // triggers a bunch of stuff, don't remove unless you know what you are doing
             bomCopy.SpecVersion = bomCopy.SpecVersion;
 
@@ -280,7 +361,7 @@ public static void EnumerateAllComponents(Bom bom, Action<Component> callback)
                 if (currentComponent != null)
                 {
                     callback(currentComponent);
-                    
+
                     q.EnqueueMany(currentComponent.Components);
                     q.EnqueueMany(currentComponent.Pedigree?.Ancestors);
                     q.EnqueueMany(currentComponent.Pedigree?.Descendants);
@@ -292,9 +373,10 @@ public static void EnumerateAllComponents(Bom bom, Action<Component> callback)
         public static void EnumerateAllServices(Bom bom, Action<Service> callback)
         {
             var q = new Queue<Service>();
-            
+
             q.EnqueueMany(bom.Metadata?.Tools?.Services);
             q.EnqueueMany(bom.Services);
+            q.EnqueueMany(bom.Annotations?.Select(an => an.Annotator).Where(anor => anor.Service != null).Select(anor => anor.Service) ?? new List<Service>());
 
             while (q.Count > 0)
             {
@@ -323,7 +405,7 @@ public static void EnumerateAllVulnerabilities(Bom bom, Action<Vulnerability> ca
             while (q.Count > 0)
             {
                 var currentVulnerability = q.Dequeue();
-                
+
                 callback(currentVulnerability);
             }
         }
@@ -334,7 +416,7 @@ public static void EnumerateAllEvidence(Bom bom, Action<Evidence> callback)
                 if (component.Evidence != null) callback(component.Evidence);
             });
         }
-        
+
         public static void EnumerateAllLicenses(Bom bom, Action<License> callback)
         {
             EnumerateAllLicenseChoices(bom, (licenseChoice) =>
@@ -351,7 +433,7 @@ public static void EnumerateAllLicenseChoices(Bom bom, Action<LicenseChoice> cal
                 {
                     callback(license);
                 }
-                    
+
             }
             EnumerateAllComponents(bom, (component) =>
             {
@@ -363,7 +445,7 @@ public static void EnumerateAllLicenseChoices(Bom bom, Action<LicenseChoice> cal
                     }
                 }
             });
-            
+
             EnumerateAllServices(bom, (service) =>
             {
                 if (service.Licenses != null)
@@ -399,9 +481,9 @@ public static void EnumerateAllOrganizationalEntity(Bom bom, Action<Organization
                     if (annotation.Annotator?.Organization != null)
                         callback(annotation.Annotator.Organization);
                 }
-                
-            }
-                
+
+            }           
+
             EnumerateAllVulnerabilities(bom, (vulnerability) =>
             {
                 if (vulnerability.Credits?.Organizations != null)
@@ -412,6 +494,20 @@ public static void EnumerateAllOrganizationalEntity(Bom bom, Action<Organization
             EnumerateAllComponents(bom, (component) =>
             {
                 if (component.Supplier != null) callback(component.Supplier);
+
+
+                component.ModelCard?.Considerations?.EnvironmentalConsiderations?.EnergyConsumptions?
+                    .ForEach(energyConsumption =>
+                        energyConsumption?.EnergyProviders?
+                            .ForEach(energyProvider =>
+                            {
+                                if (energyProvider?.Organization != null)
+                                {
+                                    callback(energyProvider.Organization);
+                                }   
+                            }));
+
+
             });
             EnumerateAllServices(bom, (service) =>
             {
@@ -431,7 +527,7 @@ public static void EnumerateAllOrganizationalContact(Bom bom, Action<Organizatio
                     }
                 }
             });
-            
+
             EnumerateAllVulnerabilities(bom, (vulnerability) =>
             {
                 if (vulnerability.Credits?.Individuals != null)
@@ -454,5 +550,35 @@ public static void EnumerateAllToolChoices(Bom bom, Action<ToolChoices> callback
                     callback(vuln.Tools);
             });
         }
+
+        public static void EnumerateAllDependencies(Bom bom, Action<Dependency> callback)
+        {
+            var q = new Queue<Dependency>();
+
+
+            q.EnqueueMany(bom.Dependencies);
+
+
+            while (q.Count > 0)
+            {
+                var currentDependency = q.Dequeue();
+                if (currentDependency != null)
+                {
+                    callback(currentDependency);
+
+                    q.EnqueueMany(currentDependency.Dependencies);
+                }
+            }
+        }
+
+        public static void EnumerateAllDatasetChoices(Bom bom, Action<DatasetChoices> callback)
+        {
+            EnumerateAllComponents(bom, (component) => {
+                if (component?.ModelCard?.ModelParameters?.Datasets != null)
+                {
+                    callback(component.ModelCard.ModelParameters.Datasets);
+                }
+            });
+        }
     }
 }