Add compliance policy for empty name and version (#3257)

* add policy for empty name and version Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> * default stub version Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> * modifying ids requires augmenting relationships Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> --------- Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
2026-10-30 14:02:26 +01:00 · 2024-09-20 12:50:47 -04:00
parent 60bbd24031
commit 963ea594c8
9 changed files with 547 additions and 47 deletions
@@ -11,6 +11,7 @@ import (

 	"github.com/anchore/syft/internal/bus"
 	"github.com/anchore/syft/internal/log"
+	"github.com/anchore/syft/internal/relationship"
 	"github.com/anchore/syft/internal/sbomsync"
 	"github.com/anchore/syft/syft/artifact"
 	"github.com/anchore/syft/syft/cataloging"
@@ -27,6 +28,7 @@ type packageTaskFactory func(cfg CatalogingFactoryConfig) Task
 type PackageTaskFactories []packageTaskFactory

 type CatalogingFactoryConfig struct {
+	ComplianceConfig     cataloging.ComplianceConfig
 	SearchConfig         cataloging.SearchConfig
 	RelationshipsConfig  cataloging.RelationshipsConfig
 	DataGenerationConfig cataloging.DataGenerationConfig
@@ -35,6 +37,7 @@ type CatalogingFactoryConfig struct {

 func DefaultCatalogingFactoryConfig() CatalogingFactoryConfig {
 	return CatalogingFactoryConfig{
+		ComplianceConfig:     cataloging.DefaultComplianceConfig(),
 		SearchConfig:         cataloging.DefaultSearchConfig(),
 		RelationshipsConfig:  cataloging.DefaultRelationshipsConfig(),
 		DataGenerationConfig: cataloging.DefaultDataGenerationConfig(),
@@ -82,7 +85,7 @@ func (f PackageTaskFactories) Tasks(cfg CatalogingFactoryConfig) ([]Task, error)
 }

 // NewPackageTask creates a Task function for a generic pkg.Cataloger, honoring the common configuration options.
-func NewPackageTask(cfg CatalogingFactoryConfig, c pkg.Cataloger, tags ...string) Task { //nolint: funlen
+func NewPackageTask(cfg CatalogingFactoryConfig, c pkg.Cataloger, tags ...string) Task {
 	fn := func(ctx context.Context, resolver file.Resolver, sbom sbomsync.Builder) error {
 		catalogerName := c.Name()
 		log.WithFields("name", catalogerName).Trace("starting package cataloger")
@@ -106,42 +109,9 @@ func NewPackageTask(cfg CatalogingFactoryConfig, c pkg.Cataloger, tags ...string

 		log.WithFields("cataloger", catalogerName).Debugf("discovered %d packages", len(pkgs))

-		for i, p := range pkgs {
-			if p.FoundBy == "" {
-				p.FoundBy = catalogerName
-			}
+		pkgs, relationships = finalizePkgCatalogerResults(cfg, resolver, catalogerName, pkgs, relationships)

-			if cfg.DataGenerationConfig.GenerateCPEs && !hasAuthoritativeCPE(p.CPEs) {
-				// generate CPEs (note: this is excluded from package ID, so is safe to mutate)
-				// we might have binary classified CPE already with the package so we want to append here
-				dictionaryCPEs, ok := cpeutils.DictionaryFind(p)
-				if ok {
-					log.Tracef("used CPE dictionary to find CPEs for %s package %q: %s", p.Type, p.Name, dictionaryCPEs)
-					p.CPEs = append(p.CPEs, dictionaryCPEs...)
-				} else {
-					p.CPEs = append(p.CPEs, cpeutils.Generate(p)...)
-				}
-			}
-
-			// if we were not able to identify the language we have an opportunity
-			// to try and get this value from the PURL. Worst case we assert that
-			// we could not identify the language at either stage and set UnknownLanguage
-			if p.Language == "" {
-				p.Language = pkg.LanguageFromPURL(p.PURL)
-			}
-
-			if cfg.RelationshipsConfig.PackageFileOwnership {
-				// create file-to-package relationships for files owned by the package
-				owningRelationships, err := packageFileOwnershipRelationships(p, resolver)
-				if err != nil {
-					log.Warnf("unable to create any package-file relationships for package name=%q type=%q: %w", p.Name, p.Type, err)
-				} else {
-					relationships = append(relationships, owningRelationships...)
-				}
-			}
-
-			pkgs[i] = p
-		}
+		pkgs, relationships = applyCompliance(cfg.ComplianceConfig, pkgs, relationships)

 		sbom.AddPackages(pkgs...)
 		sbom.AddRelationships(relationships...)
@@ -157,6 +127,136 @@ func NewPackageTask(cfg CatalogingFactoryConfig, c pkg.Cataloger, tags ...string
 	return NewTask(c.Name(), fn, tags...)
 }

+func finalizePkgCatalogerResults(cfg CatalogingFactoryConfig, resolver file.PathResolver, catalogerName string, pkgs []pkg.Package, relationships []artifact.Relationship) ([]pkg.Package, []artifact.Relationship) {
+	for i, p := range pkgs {
+		if p.FoundBy == "" {
+			p.FoundBy = catalogerName
+		}
+
+		if cfg.DataGenerationConfig.GenerateCPEs && !hasAuthoritativeCPE(p.CPEs) {
+			// generate CPEs (note: this is excluded from package ID, so is safe to mutate)
+			// we might have binary classified CPE already with the package so we want to append here
+			dictionaryCPEs, ok := cpeutils.DictionaryFind(p)
+			if ok {
+				log.Tracef("used CPE dictionary to find CPEs for %s package %q: %s", p.Type, p.Name, dictionaryCPEs)
+				p.CPEs = append(p.CPEs, dictionaryCPEs...)
+			} else {
+				p.CPEs = append(p.CPEs, cpeutils.Generate(p)...)
+			}
+		}
+
+		// if we were not able to identify the language we have an opportunity
+		// to try and get this value from the PURL. Worst case we assert that
+		// we could not identify the language at either stage and set UnknownLanguage
+		if p.Language == "" {
+			p.Language = pkg.LanguageFromPURL(p.PURL)
+		}
+
+		if cfg.RelationshipsConfig.PackageFileOwnership {
+			// create file-to-package relationships for files owned by the package
+			owningRelationships, err := packageFileOwnershipRelationships(p, resolver)
+			if err != nil {
+				log.Warnf("unable to create any package-file relationships for package name=%q type=%q: %v", p.Name, p.Type, err)
+			} else {
+				relationships = append(relationships, owningRelationships...)
+			}
+		}
+
+		pkgs[i] = p
+	}
+	return pkgs, relationships
+}
+
+type packageReplacement struct {
+	original artifact.ID
+	pkg      pkg.Package
+}
+
+func applyCompliance(cfg cataloging.ComplianceConfig, pkgs []pkg.Package, relationships []artifact.Relationship) ([]pkg.Package, []artifact.Relationship) {
+	remainingPkgs, droppedPkgs, replacements := filterNonCompliantPackages(pkgs, cfg)
+
+	relIdx := relationship.NewIndex(relationships...)
+	for _, p := range droppedPkgs {
+		relIdx.Remove(p.ID())
+	}
+
+	for _, replacement := range replacements {
+		relIdx.Replace(replacement.original, replacement.pkg)
+	}
+
+	return remainingPkgs, relIdx.All()
+}
+
+func filterNonCompliantPackages(pkgs []pkg.Package, cfg cataloging.ComplianceConfig) ([]pkg.Package, []pkg.Package, []packageReplacement) {
+	var remainingPkgs, droppedPkgs []pkg.Package
+	var replacements []packageReplacement
+	for _, p := range pkgs {
+		keep, replacement := applyComplianceRules(&p, cfg)
+		if keep {
+			remainingPkgs = append(remainingPkgs, p)
+		} else {
+			droppedPkgs = append(droppedPkgs, p)
+		}
+		if replacement != nil {
+			replacements = append(replacements, *replacement)
+		}
+	}
+
+	return remainingPkgs, droppedPkgs, replacements
+}
+
+func applyComplianceRules(p *pkg.Package, cfg cataloging.ComplianceConfig) (bool, *packageReplacement) {
+	var drop bool
+	var replacement *packageReplacement
+
+	applyComplianceRule := func(value, fieldName string, action cataloging.ComplianceAction) bool {
+		if strings.TrimSpace(value) != "" {
+			return false
+		}
+
+		loc := "unknown"
+		locs := p.Locations.ToSlice()
+		if len(locs) > 0 {
+			loc = locs[0].Path()
+		}
+		switch action {
+		case cataloging.ComplianceActionDrop:
+			log.WithFields("pkg", p.String(), "location", loc).Debugf("package with missing %s, dropping", fieldName)
+			drop = true
+
+		case cataloging.ComplianceActionStub:
+			log.WithFields("pkg", p.String(), "location", loc).Debugf("package with missing %s, stubbing with default value", fieldName)
+			return true
+
+		case cataloging.ComplianceActionKeep:
+			log.WithFields("pkg", p.String(), "location", loc).Tracef("package with missing %s, taking no action", fieldName)
+		}
+		return false
+	}
+
+	ogID := p.ID()
+
+	if applyComplianceRule(p.Name, "name", cfg.MissingName) {
+		p.Name = cataloging.UnknownStubValue
+		p.SetID()
+	}
+
+	if applyComplianceRule(p.Version, "version", cfg.MissingVersion) {
+		p.Version = cataloging.UnknownStubValue
+		p.SetID()
+	}
+
+	newID := p.ID()
+	if newID != ogID {
+		replacement = &packageReplacement{
+			original: ogID,
+			pkg:      *p,
+		}
+	}
+
+	return !drop, replacement
+}
+
 func hasAuthoritativeCPE(cpes []cpe.CPE) bool {
 	for _, c := range cpes {
 		if c.Source != cpe.GeneratedSource {