add symlink content fetching support

imgbom/cataloger/bundler/cataloger.go

@@ -3,8 +3,8 @@ package bundler
 import (
 	"github.com/anchore/imgbom/imgbom/cataloger/common"
 	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/imgbom/scope"
 	"github.com/anchore/stereoscope/pkg/file"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
 type Cataloger struct {
@@ -25,8 +25,8 @@ func (a *Cataloger) Name() string {
 	return "bundler-cataloger"
 }
 
-func (a *Cataloger) SelectFiles(trees []tree.FileTreeReader) []file.Reference {
-	return a.cataloger.SelectFiles(trees)
+func (a *Cataloger) SelectFiles(resolver scope.FileResolver) []file.Reference {
+	return a.cataloger.SelectFiles(resolver)
 }
 
 func (a *Cataloger) Catalog(contents map[file.Reference]string) ([]pkg.Package, error) {

imgbom/cataloger/cataloger.go

@@ -2,14 +2,14 @@ package cataloger
 
 import (
 	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/imgbom/scope"
 	"github.com/anchore/stereoscope/pkg/file"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
 type Cataloger interface {
 	Name() string
 	// TODO: add ID / Name for catalog for uniquely identifying this cataloger type
-	SelectFiles([]tree.FileTreeReader) []file.Reference
+	SelectFiles(scope.FileResolver) []file.Reference
 	// NOTE: one of the errors which is returned is "IterationNeeded", which indicates to the driver to
 	// continue with another Select/Catalog pass
 	Catalog(map[file.Reference]string) ([]pkg.Package, error)

imgbom/cataloger/common/generic_cataloger.go

@@ -4,13 +4,11 @@ import (
 	"strings"
 
 	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/imgbom/scope"
 	"github.com/anchore/imgbom/internal/log"
 	"github.com/anchore/stereoscope/pkg/file"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
-// TODO: put under test...
-
 // GenericCataloger implements the Catalog interface and is responsible for dispatching the proper parser function for
 // a given path or glob pattern. This is intended to be reusable across many package cataloger types.
 type GenericCataloger struct {
@@ -45,25 +43,26 @@ func (a *GenericCataloger) clear() {
 }
 
 // SelectFiles takes a set of file trees and resolves and file references of interest for future cataloging
-func (a *GenericCataloger) SelectFiles(trees []tree.FileTreeReader) []file.Reference {
-	for _, t := range trees {
-		// select by exact path
-		for path, parser := range a.pathParsers {
-			f := t.File(file.Path(path))
-			if f != nil {
-				a.register([]file.Reference{*f}, parser)
-			}
+func (a *GenericCataloger) SelectFiles(resolver scope.FileResolver) []file.Reference {
+	// select by exact path
+	for path, parser := range a.pathParsers {
+		files, err := resolver.FilesByPath(file.Path(path))
+		if err != nil {
+			log.Errorf("cataloger failed to select files by path: %w", err)
 		}
+		if files != nil {
+			a.register(files, parser)
+		}
+	}
 
-		// select by pattern
-		for globPattern, parser := range a.globParsers {
-			fileMatches, err := t.FilesByGlob(globPattern)
-			if err != nil {
-				log.Errorf("failed to find files by glob: %s", globPattern)
-			}
-			if fileMatches != nil {
-				a.register(fileMatches, parser)
-			}
+	// select by glob pattern
+	for globPattern, parser := range a.globParsers {
+		fileMatches, err := resolver.FilesByGlob(globPattern)
+		if err != nil {
+			log.Errorf("failed to find files by glob: %s", globPattern)
+		}
+		if fileMatches != nil {
+			a.register(fileMatches, parser)
 		}
 	}
 

imgbom/cataloger/common/generic_cataloger_test.go

@@ -0,0 +1,117 @@
+package common
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"testing"
+
+	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/internal"
+	"github.com/anchore/stereoscope/pkg/file"
+)
+
+type testResolver struct {
+	contents map[file.Reference]string
+}
+
+func newTestResolver() *testResolver {
+	return &testResolver{
+		contents: make(map[file.Reference]string),
+	}
+}
+
+func (r *testResolver) FilesByPath(paths ...file.Path) ([]file.Reference, error) {
+	results := make([]file.Reference, len(paths))
+
+	for idx, p := range paths {
+		results[idx] = file.NewFileReference(p)
+		r.contents[results[idx]] = fmt.Sprintf("%s file contents!", p)
+	}
+
+	return results, nil
+}
+
+func (r *testResolver) FilesByGlob(patterns ...string) ([]file.Reference, error) {
+	path := "/a-path.txt"
+	ref := file.NewFileReference(file.Path(path))
+	r.contents[ref] = fmt.Sprintf("%s file contents!", path)
+	return []file.Reference{ref}, nil
+}
+
+func parser(reader io.Reader) ([]pkg.Package, error) {
+	contents, err := ioutil.ReadAll(reader)
+	if err != nil {
+		panic(err)
+	}
+	return []pkg.Package{
+		{
+			Name: string(contents),
+		},
+	}, nil
+}
+
+func TestGenericCataloger(t *testing.T) {
+
+	globParsers := map[string]ParserFn{
+		"**a-path.txt": parser,
+	}
+	pathParsers := map[string]ParserFn{
+		"/another-path.txt": parser,
+		"/last/path.txt":    parser,
+	}
+
+	resolver := newTestResolver()
+	cataloger := NewGenericCataloger(pathParsers, globParsers)
+
+	selected := cataloger.SelectFiles(resolver)
+
+	if len(selected) != 3 {
+		t.Fatalf("unexpected selection length: %d", len(selected))
+	}
+
+	expectedSelection := internal.NewStringSetFromSlice([]string{"/last/path.txt", "/another-path.txt", "/a-path.txt"})
+	selectionByPath := make(map[string]file.Reference)
+	for _, s := range selected {
+		if !expectedSelection.Contains(string(s.Path)) {
+			t.Errorf("unexpected selection path: %+v", s.Path)
+		}
+		selectionByPath[string(s.Path)] = s
+	}
+
+	upstream := "some-other-cataloger"
+	expectedPkgs := make(map[file.Reference]pkg.Package)
+	for path, ref := range selectionByPath {
+		expectedPkgs[ref] = pkg.Package{
+			FoundBy: upstream,
+			Source:  []file.Reference{ref},
+			Name:    fmt.Sprintf("%s file contents!", path),
+		}
+	}
+
+	actualPkgs, err := cataloger.Catalog(resolver.contents, upstream)
+	if err != nil {
+		t.Fatalf("cataloger catalog action failed: %+v", err)
+	}
+
+	if len(actualPkgs) != len(expectedPkgs) {
+		t.Fatalf("unexpected packages len: %d", len(actualPkgs))
+	}
+
+	for _, p := range actualPkgs {
+		ref := p.Source[0]
+		exP, ok := expectedPkgs[ref]
+		if !ok {
+			t.Errorf("missing expected pkg: ref=%+v", ref)
+			continue
+		}
+
+		if p.FoundBy != exP.FoundBy {
+			t.Errorf("bad upstream: %s", p.FoundBy)
+		}
+
+		if exP.Name != p.Name {
+			t.Errorf("bad contents mapping: %+v", p.Source)
+		}
+	}
+}

imgbom/cataloger/controller.go

@@ -17,6 +17,14 @@ func init() {
 	controllerInstance = newController()
 }
 
+func Catalogers() []string {
+	c := make([]string, len(controllerInstance.catalogers))
+	for idx, catalog := range controllerInstance.catalogers {
+		c[idx] = catalog.Name()
+	}
+	return c
+}
+
 func Catalog(s scope.Scope) (*pkg.Catalog, error) {
 	return controllerInstance.catalog(s)
 }
@@ -46,7 +54,7 @@ func (c *controller) catalog(s scope.Scope) (*pkg.Catalog, error) {
 
 	// ask catalogers for files to extract from the image tar
 	for _, a := range c.catalogers {
-		fileSelection = append(fileSelection, a.SelectFiles(s.Trees)...)
+		fileSelection = append(fileSelection, a.SelectFiles(&s)...)
 		log.Debugf("cataloger '%s' selected '%d' files", a.Name(), len(fileSelection))
 	}
 

imgbom/cataloger/dpkg/cataloger.go

@@ -3,8 +3,8 @@ package dpkg
 import (
 	"github.com/anchore/imgbom/imgbom/cataloger/common"
 	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/imgbom/scope"
 	"github.com/anchore/stereoscope/pkg/file"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
 type Cataloger struct {
@@ -25,8 +25,8 @@ func (a *Cataloger) Name() string {
 	return "dpkg-cataloger"
 }
 
-func (a *Cataloger) SelectFiles(trees []tree.FileTreeReader) []file.Reference {
-	return a.cataloger.SelectFiles(trees)
+func (a *Cataloger) SelectFiles(resolver scope.FileResolver) []file.Reference {
+	return a.cataloger.SelectFiles(resolver)
 }
 
 func (a *Cataloger) Catalog(contents map[file.Reference]string) ([]pkg.Package, error) {

imgbom/cataloger/python/cataloger.go

@@ -3,8 +3,8 @@ package python
 import (
 	"github.com/anchore/imgbom/imgbom/cataloger/common"
 	"github.com/anchore/imgbom/imgbom/pkg"
+	"github.com/anchore/imgbom/imgbom/scope"
 	"github.com/anchore/stereoscope/pkg/file"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
 type Cataloger struct {
@@ -26,8 +26,8 @@ func (a *Cataloger) Name() string {
 	return "python-cataloger"
 }
 
-func (a *Cataloger) SelectFiles(trees []tree.FileTreeReader) []file.Reference {
-	return a.cataloger.SelectFiles(trees)
+func (a *Cataloger) SelectFiles(resolver scope.FileResolver) []file.Reference {
+	return a.cataloger.SelectFiles(resolver)
 }
 
 func (a *Cataloger) Catalog(contents map[file.Reference]string) ([]pkg.Package, error) {

imgbom/distro/identify.go

@@ -20,15 +20,14 @@ func Identify(img *image.Image) *Distro {
 		"/etc/os-release": parseOsRelease,
 		// Debian and Debian-based distros have the same contents linked from this path
 		"/usr/lib/os-release": parseOsRelease,
-		// TODO: change this to /bin/busybox when stereoscope deals with hardlinks
-		"/bin/[": parseBusyBox,
+		"/bin/busybox":        parseBusyBox,
 	}
 
 	for path, fn := range identityFiles {
 		contents, err := img.FileContentsFromSquash(path)
 
 		if err != nil {
-			log.Errorf("unable to get contents from %s: %s", path, err)
+			log.Debugf("unable to get contents from %s: %s", path, err)
 			continue
 		}
 

imgbom/presenter/json/presenter_test.go

@@ -53,7 +53,7 @@ func TestJsonPresenter(t *testing.T) {
 		Name:    "package-1",
 		Version: "1.0.1",
 		Source: []file.Reference{
-			*img.SquashedTree.File("/somefile-1.txt"),
+			*img.SquashedTree().File("/somefile-1.txt"),
 		},
 		Type: pkg.DebPkg,
 	})
@@ -61,7 +61,7 @@ func TestJsonPresenter(t *testing.T) {
 		Name:    "package-2",
 		Version: "2.0.1",
 		Source: []file.Reference{
-			*img.SquashedTree.File("/somefile-2.txt"),
+			*img.SquashedTree().File("/somefile-2.txt"),
 		},
 		Type: pkg.DebPkg,
 	})

imgbom/scope/file_resolver.go

@@ -0,0 +1,25 @@
+package scope
+
+import (
+	"fmt"
+
+	"github.com/anchore/imgbom/imgbom/scope/resolvers"
+	"github.com/anchore/stereoscope/pkg/file"
+	"github.com/anchore/stereoscope/pkg/image"
+)
+
+type FileResolver interface {
+	FilesByPath(paths ...file.Path) ([]file.Reference, error)
+	FilesByGlob(patterns ...string) ([]file.Reference, error)
+}
+
+func getFileResolver(img *image.Image, option Option) (FileResolver, error) {
+	switch option {
+	case SquashedScope:
+		return resolvers.NewImageSquashResolver(img)
+	case AllLayersScope:
+		return resolvers.NewAllLayersResolver(img)
+	default:
+		return nil, fmt.Errorf("bad option provided: %+v", option)
+	}
+}

imgbom/scope/resolvers/all_layers_resolver.go

@@ -0,0 +1,106 @@
+package resolvers
+
+import (
+	"archive/tar"
+	"fmt"
+
+	"github.com/anchore/stereoscope/pkg/file"
+	"github.com/anchore/stereoscope/pkg/image"
+)
+
+type AllLayersResolver struct {
+	img    *image.Image
+	layers []int
+}
+
+func NewAllLayersResolver(img *image.Image) (*AllLayersResolver, error) {
+	if len(img.Layers) == 0 {
+		return nil, fmt.Errorf("the image does not contain any layers")
+	}
+
+	var layers = make([]int, 0)
+	for idx := range img.Layers {
+		layers = append(layers, idx)
+	}
+	return &AllLayersResolver{
+		img:    img,
+		layers: layers,
+	}, nil
+}
+
+func (r *AllLayersResolver) fileByRef(ref file.Reference, uniqueFileIDs file.ReferenceSet, layerIdx int) ([]file.Reference, error) {
+	uniqueFiles := make([]file.Reference, 0)
+
+	// since there is potentially considerable work for each symlink/hardlink that needs to be resolved, let's check to see if this is a symlink/hardlink first
+	entry, err := r.img.FileCatalog.Get(ref)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch metadata (ref=%+v): %w", ref, err)
+	}
+
+	if entry.Metadata.TypeFlag == tar.TypeLink || entry.Metadata.TypeFlag == tar.TypeSymlink {
+		// a link may resolve in this layer or higher, assuming a squashed tree is used to search
+		// we should search all possible resolutions within the valid scope
+		for _, subLayerIdx := range r.layers[layerIdx:] {
+			resolvedRef, err := r.img.ResolveLinkByLayerSquash(ref, subLayerIdx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve link from layer (layer=%d ref=%+v): %w", subLayerIdx, ref, err)
+			}
+			if resolvedRef != nil && !uniqueFileIDs.Contains(*resolvedRef) {
+				uniqueFileIDs.Add(*resolvedRef)
+				uniqueFiles = append(uniqueFiles, *resolvedRef)
+			}
+		}
+	} else if !uniqueFileIDs.Contains(ref) {
+		uniqueFileIDs.Add(ref)
+		uniqueFiles = append(uniqueFiles, ref)
+	}
+
+	return uniqueFiles, nil
+}
+
+func (r *AllLayersResolver) FilesByPath(paths ...file.Path) ([]file.Reference, error) {
+	uniqueFileIDs := file.NewFileReferenceSet()
+	uniqueFiles := make([]file.Reference, 0)
+
+	for _, path := range paths {
+		for idx, layerIdx := range r.layers {
+			ref := r.img.Layers[layerIdx].Tree.File(path)
+			if ref == nil {
+				// no file found, keep looking through layers
+				continue
+			}
+
+			results, err := r.fileByRef(*ref, uniqueFileIDs, idx)
+			if err != nil {
+				return nil, err
+			}
+			uniqueFiles = append(uniqueFiles, results...)
+		}
+	}
+
+	return uniqueFiles, nil
+}
+
+func (r *AllLayersResolver) FilesByGlob(patterns ...string) ([]file.Reference, error) {
+	uniqueFileIDs := file.NewFileReferenceSet()
+	uniqueFiles := make([]file.Reference, 0)
+
+	for _, pattern := range patterns {
+		for idx, layerIdx := range r.layers {
+			refs, err := r.img.Layers[layerIdx].Tree.FilesByGlob(pattern)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve files by glob (%s): %w", pattern, err)
+			}
+
+			for _, ref := range refs {
+				results, err := r.fileByRef(ref, uniqueFileIDs, idx)
+				if err != nil {
+					return nil, err
+				}
+				uniqueFiles = append(uniqueFiles, results...)
+			}
+		}
+	}
+
+	return uniqueFiles, nil
+}

imgbom/scope/resolvers/all_layers_resolver_test.go

@@ -0,0 +1,229 @@
+package resolvers
+
+import (
+	"testing"
+
+	"github.com/anchore/go-testutils"
+	"github.com/anchore/stereoscope/pkg/file"
+)
+
+type resolution struct {
+	layer uint
+	path  string
+}
+
+func TestAllLayersResolver_FilesByPath(t *testing.T) {
+	cases := []struct {
+		name        string
+		linkPath    string
+		resolutions []resolution
+	}{
+		{
+			name:     "link with previous data",
+			linkPath: "/link-1",
+			resolutions: []resolution{
+				{
+					layer: 1,
+					path:  "/file-1.txt",
+				},
+			},
+		},
+		{
+			name:     "link with in layer data",
+			linkPath: "/link-within",
+			resolutions: []resolution{
+				{
+					layer: 5,
+					path:  "/file-3.txt",
+				},
+			},
+		},
+		{
+			name:     "link with overridden data",
+			linkPath: "/link-2",
+			resolutions: []resolution{
+				{
+					layer: 3,
+					path:  "/link-2",
+				},
+				{
+					layer: 4,
+					path:  "/file-2.txt",
+				},
+				{
+					layer: 7,
+					path:  "/file-2.txt",
+				},
+			},
+		},
+		{
+			name:     "indirect link (with overridden data)",
+			linkPath: "/link-indirect",
+			resolutions: []resolution{
+				{
+					layer: 4,
+					path:  "/file-2.txt",
+				},
+				{
+					layer: 7,
+					path:  "/file-2.txt",
+				},
+			},
+		},
+		{
+			name:     "dead link",
+			linkPath: "/link-dead",
+			resolutions: []resolution{
+				{
+					layer: 8,
+					path:  "/link-dead",
+				},
+			},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			img, cleanup := testutils.GetFixtureImage(t, "docker-archive", "image-symlinks")
+			defer cleanup()
+
+			resolver, err := NewAllLayersResolver(img)
+			if err != nil {
+				t.Fatalf("could not create resolver: %+v", err)
+			}
+
+			refs, err := resolver.FilesByPath(file.Path(c.linkPath))
+			if err != nil {
+				t.Fatalf("could not use resolver: %+v", err)
+			}
+
+			if len(refs) != len(c.resolutions) {
+				t.Fatalf("unexpected number of resolutions: %d", len(refs))
+			}
+
+			for idx, actual := range refs {
+				expected := c.resolutions[idx]
+
+				if actual.Path != file.Path(expected.path) {
+					t.Errorf("bad resolve path: '%s'!='%s'", actual.Path, expected.path)
+				}
+
+				entry, err := img.FileCatalog.Get(actual)
+				if err != nil {
+					t.Fatalf("failed to get metadata: %+v", err)
+				}
+
+				if entry.Source.Metadata.Index != expected.layer {
+					t.Errorf("bad resolve layer: '%d'!='%d'", entry.Source.Metadata.Index, expected.layer)
+				}
+			}
+		})
+	}
+}
+
+func TestAllLayersResolver_FilesByGlob(t *testing.T) {
+	cases := []struct {
+		name        string
+		glob        string
+		resolutions []resolution
+	}{
+		{
+			name: "link with previous data",
+			glob: "**ink-1",
+			resolutions: []resolution{
+				{
+					layer: 1,
+					path:  "/file-1.txt",
+				},
+			},
+		},
+		{
+			name: "link with in layer data",
+			glob: "**nk-within",
+			resolutions: []resolution{
+				{
+					layer: 5,
+					path:  "/file-3.txt",
+				},
+			},
+		},
+		{
+			name: "link with overridden data",
+			glob: "**ink-2",
+			resolutions: []resolution{
+				{
+					layer: 3,
+					path:  "/link-2",
+				},
+				{
+					layer: 4,
+					path:  "/file-2.txt",
+				},
+				{
+					layer: 7,
+					path:  "/file-2.txt",
+				},
+			},
+		},
+		{
+			name: "indirect link (with overridden data)",
+			glob: "**nk-indirect",
+			resolutions: []resolution{
+				{
+					layer: 4,
+					path:  "/file-2.txt",
+				},
+				{
+					layer: 7,
+					path:  "/file-2.txt",
+				},
+			},
+		},
+		{
+			name: "dead link",
+			glob: "**k-dead",
+			resolutions: []resolution{
+				{
+					layer: 8,
+					path:  "/link-dead",
+				},
+			},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			img, cleanup := testutils.GetFixtureImage(t, "docker-archive", "image-symlinks")
+			defer cleanup()
+
+			resolver, err := NewAllLayersResolver(img)
+			if err != nil {
+				t.Fatalf("could not create resolver: %+v", err)
+			}
+
+			refs, err := resolver.FilesByGlob(c.glob)
+			if err != nil {
+				t.Fatalf("could not use resolver: %+v", err)
+			}
+
+			if len(refs) != len(c.resolutions) {
+				t.Fatalf("unexpected number of resolutions: %d", len(refs))
+			}
+
+			for idx, actual := range refs {
+				expected := c.resolutions[idx]
+
+				if actual.Path != file.Path(expected.path) {
+					t.Errorf("bad resolve path: '%s'!='%s'", actual.Path, expected.path)
+				}
+
+				entry, err := img.FileCatalog.Get(actual)
+				if err != nil {
+					t.Fatalf("failed to get metadata: %+v", err)
+				}
+
+				if entry.Source.Metadata.Index != expected.layer {
+					t.Errorf("bad resolve layer: '%d'!='%d'", entry.Source.Metadata.Index, expected.layer)
+				}
+			}
+		})
+	}
+}

imgbom/scope/resolvers/image_squash_resolver.go

@@ -0,0 +1,70 @@
+package resolvers
+
+import (
+	"fmt"
+
+	"github.com/anchore/stereoscope/pkg/file"
+	"github.com/anchore/stereoscope/pkg/image"
+)
+
+type ImageSquashResolver struct {
+	img *image.Image
+}
+
+func NewImageSquashResolver(img *image.Image) (*ImageSquashResolver, error) {
+	if img.SquashedTree() == nil {
+		return nil, fmt.Errorf("the image does not have have a squashed tree")
+	}
+	return &ImageSquashResolver{img: img}, nil
+}
+
+func (r *ImageSquashResolver) FilesByPath(paths ...file.Path) ([]file.Reference, error) {
+	uniqueFileIDs := file.NewFileReferenceSet()
+	uniqueFiles := make([]file.Reference, 0)
+
+	for _, path := range paths {
+		ref := r.img.SquashedTree().File(path)
+		if ref == nil {
+			// no file found, keep looking through layers
+			continue
+		}
+
+		resolvedRef, err := r.img.ResolveLinkByImageSquash(*ref)
+		if err != nil {
+			return nil, fmt.Errorf("failed to resolve link from img (ref=%+v): %w", ref, err)
+		}
+		if resolvedRef != nil && !uniqueFileIDs.Contains(*resolvedRef) {
+			uniqueFileIDs.Add(*resolvedRef)
+			uniqueFiles = append(uniqueFiles, *resolvedRef)
+		}
+	}
+
+	return uniqueFiles, nil
+}
+
+func (r *ImageSquashResolver) FilesByGlob(patterns ...string) ([]file.Reference, error) {
+	uniqueFileIDs := file.NewFileReferenceSet()
+	uniqueFiles := make([]file.Reference, 0)
+
+	for _, pattern := range patterns {
+		refs, err := r.img.SquashedTree().FilesByGlob(pattern)
+		if err != nil {
+			return nil, fmt.Errorf("failed to resolve files by glob (%s): %w", pattern, err)
+		}
+
+		for _, ref := range refs {
+			resolvedRefs, err := r.FilesByPath(ref.Path)
+			if err != nil {
+				return nil, fmt.Errorf("failed to find files by path (ref=%+v): %w", ref, err)
+			}
+			for _, resolvedRef := range resolvedRefs {
+				if !uniqueFileIDs.Contains(resolvedRef) {
+					uniqueFileIDs.Add(resolvedRef)
+					uniqueFiles = append(uniqueFiles, resolvedRef)
+				}
+			}
+		}
+	}
+
+	return uniqueFiles, nil
+}

imgbom/scope/resolvers/image_squash_resolver_test.go

@@ -0,0 +1,158 @@
+package resolvers
+
+import (
+	"testing"
+
+	"github.com/anchore/go-testutils"
+	"github.com/anchore/stereoscope/pkg/file"
+)
+
+func TestImageSquashResolver_FilesByPath(t *testing.T) {
+	cases := []struct {
+		name         string
+		linkPath     string
+		resolveLayer uint
+		resolvePath  string
+	}{
+		{
+			name:         "link with previous data",
+			linkPath:     "/link-1",
+			resolveLayer: 1,
+			resolvePath:  "/file-1.txt",
+		},
+		{
+			name:         "link with in layer data",
+			linkPath:     "/link-within",
+			resolveLayer: 5,
+			resolvePath:  "/file-3.txt",
+		},
+		{
+			name:         "link with overridden data",
+			linkPath:     "/link-2",
+			resolveLayer: 7,
+			resolvePath:  "/file-2.txt",
+		},
+		{
+			name:         "indirect link (with overridden data)",
+			linkPath:     "/link-indirect",
+			resolveLayer: 7,
+			resolvePath:  "/file-2.txt",
+		},
+		{
+			name:         "dead link",
+			linkPath:     "/link-dead",
+			resolveLayer: 8,
+			resolvePath:  "/link-dead",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			img, cleanup := testutils.GetFixtureImage(t, "docker-archive", "image-symlinks")
+			defer cleanup()
+
+			resolver, err := NewImageSquashResolver(img)
+			if err != nil {
+				t.Fatalf("could not create resolver: %+v", err)
+			}
+
+			refs, err := resolver.FilesByPath(file.Path(c.linkPath))
+			if err != nil {
+				t.Fatalf("could not use resolver: %+v", err)
+			}
+
+			if len(refs) != 1 {
+				t.Fatalf("unexpected number of resolutions: %d", len(refs))
+			}
+
+			actual := refs[0]
+
+			if actual.Path != file.Path(c.resolvePath) {
+				t.Errorf("bad resolve path: '%s'!='%s'", actual.Path, c.resolvePath)
+			}
+
+			entry, err := img.FileCatalog.Get(actual)
+			if err != nil {
+				t.Fatalf("failed to get metadata: %+v", err)
+			}
+
+			if entry.Source.Metadata.Index != c.resolveLayer {
+				t.Errorf("bad resolve layer: '%d'!='%d'", entry.Source.Metadata.Index, c.resolveLayer)
+			}
+		})
+	}
+}
+
+func TestImageSquashResolver_FilesByGlob(t *testing.T) {
+	cases := []struct {
+		name         string
+		glob         string
+		resolveLayer uint
+		resolvePath  string
+	}{
+		{
+			name:         "link with previous data",
+			glob:         "**link-1",
+			resolveLayer: 1,
+			resolvePath:  "/file-1.txt",
+		},
+		{
+			name:         "link with in layer data",
+			glob:         "**link-within",
+			resolveLayer: 5,
+			resolvePath:  "/file-3.txt",
+		},
+		{
+			name:         "link with overridden data",
+			glob:         "**link-2",
+			resolveLayer: 7,
+			resolvePath:  "/file-2.txt",
+		},
+		{
+			name:         "indirect link (with overridden data)",
+			glob:         "**link-indirect",
+			resolveLayer: 7,
+			resolvePath:  "/file-2.txt",
+		},
+		{
+			name:         "dead link",
+			glob:         "**link-dead",
+			resolveLayer: 8,
+			resolvePath:  "/link-dead",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			img, cleanup := testutils.GetFixtureImage(t, "docker-archive", "image-symlinks")
+			defer cleanup()
+
+			resolver, err := NewImageSquashResolver(img)
+			if err != nil {
+				t.Fatalf("could not create resolver: %+v", err)
+			}
+
+			refs, err := resolver.FilesByGlob(c.glob)
+			if err != nil {
+				t.Fatalf("could not use resolver: %+v", err)
+			}
+
+			if len(refs) != 1 {
+				t.Fatalf("unexpected number of resolutions: %d", len(refs))
+			}
+
+			actual := refs[0]
+
+			if actual.Path != file.Path(c.resolvePath) {
+				t.Errorf("bad resolve path: '%s'!='%s'", actual.Path, c.resolvePath)
+			}
+
+			entry, err := img.FileCatalog.Get(actual)
+			if err != nil {
+				t.Fatalf("failed to get metadata: %+v", err)
+			}
+
+			if entry.Source.Metadata.Index != c.resolveLayer {
+				t.Errorf("bad resolve layer: '%d'!='%d'", entry.Source.Metadata.Index, c.resolveLayer)
+			}
+		})
+	}
+}

imgbom/scope/resolvers/test-fixtures/image-symlinks/Dockerfile

@@ -0,0 +1,24 @@
+# LAYER 0:
+FROM busybox:latest
+
+# LAYER 1:
+ADD file-1.txt .
+# LAYER 2: link with previous data
+RUN ln -s ./file-1.txt link-1
+
+# LAYER 3: link with future data
+RUN ln -s ./file-2.txt link-2
+# LAYER 4:
+ADD file-2.txt .
+
+# LAYER 5: link with current data
+RUN echo "file 3" > file-3.txt && ln -s ./file-3.txt link-within
+
+# LAYER 6: multiple links (link-indirect > link-2 > file-2.txt)
+RUN ln -s ./link-2 link-indirect
+
+# LAYER 7: override contents / resolution
+ADD new-file-2.txt file-2.txt
+
+# LAYER 8: dead link
+RUN ln -s ./i-dont-exist.txt link-dead

imgbom/scope/resolvers/test-fixtures/image-symlinks/file-1.txt

@@ -0,0 +1 @@
+file 1!

imgbom/scope/resolvers/test-fixtures/image-symlinks/file-2.txt

@@ -0,0 +1 @@
+file 2!

imgbom/scope/resolvers/test-fixtures/image-symlinks/new-file-2.txt

@@ -0,0 +1 @@
+NEW file override!

imgbom/scope/scope.go

@@ -3,44 +3,37 @@ package scope
 import (
 	"fmt"
 
+	"github.com/anchore/stereoscope/pkg/file"
 	"github.com/anchore/stereoscope/pkg/image"
-	"github.com/anchore/stereoscope/pkg/tree"
 )
 
 type Scope struct {
-	Option Option
-	Trees  []tree.FileTreeReader
-	Image  *image.Image
+	Option   Option
+	resolver FileResolver
+	Image    *image.Image
 }
 
 func NewScope(img *image.Image, option Option) (Scope, error) {
-	var trees = make([]tree.FileTreeReader, 0)
-
 	if img == nil {
 		return Scope{}, fmt.Errorf("no image given")
 	}
 
-	switch option {
-	case SquashedScope:
-		if img.SquashedTree == nil {
-			return Scope{}, fmt.Errorf("the image does not have have a squashed tree")
-		}
-		trees = append(trees, img.SquashedTree)
-
-	case AllLayersScope:
-		if len(img.Layers) == 0 {
-			return Scope{}, fmt.Errorf("the image does not contain any layers")
-		}
-		for _, layer := range img.Layers {
-			trees = append(trees, layer.Tree)
-		}
-	default:
-		return Scope{}, fmt.Errorf("bad option provided: %+v", option)
+	resolver, err := getFileResolver(img, option)
+	if err != nil {
+		return Scope{}, fmt.Errorf("could not determine file resolver: %w", err)
 	}
 
 	return Scope{
-		Option: option,
-		Trees:  trees,
-		Image:  img,
+		Option:   option,
+		resolver: resolver,
+		Image:    img,
 	}, nil
 }
+
+func (s Scope) FilesByPath(paths ...file.Path) ([]file.Reference, error) {
+	return s.resolver.FilesByPath(paths...)
+}
+
+func (s Scope) FilesByGlob(patterns ...string) ([]file.Reference, error) {
+	return s.resolver.FilesByGlob(patterns...)
+}

imgbom/scope/scope_test.go

@@ -1,95 +0,0 @@
-package scope
-
-import (
-	"testing"
-
-	"github.com/anchore/stereoscope/pkg/image"
-	"github.com/anchore/stereoscope/pkg/tree"
-)
-
-func testScopeImage(t *testing.T) *image.Image {
-	t.Helper()
-
-	one := image.NewLayer(nil)
-	one.Tree = tree.NewFileTree()
-	one.Tree.AddPath("/tree/first/path.txt")
-
-	two := image.NewLayer(nil)
-	two.Tree = tree.NewFileTree()
-	two.Tree.AddPath("/tree/second/path.txt")
-
-	i := image.NewImage(nil)
-	i.Layers = []image.Layer{one, two}
-	err := i.Squash()
-	if err != nil {
-		t.Fatal("could not squash test image trees")
-	}
-
-	return i
-}
-
-func TestScope(t *testing.T) {
-	refImg := testScopeImage(t)
-
-	cases := []struct {
-		name          string
-		img           *image.Image
-		option        Option
-		expectedTrees []*tree.FileTree
-		err           bool
-	}{
-		{
-			name:          "AllLayersGoCase",
-			option:        AllLayersScope,
-			img:           testScopeImage(t),
-			expectedTrees: []*tree.FileTree{refImg.Layers[0].Tree, refImg.Layers[1].Tree},
-		},
-		{
-			name:          "SquashedGoCase",
-			option:        SquashedScope,
-			img:           testScopeImage(t),
-			expectedTrees: []*tree.FileTree{refImg.SquashedTree},
-		},
-		{
-			name:   "MissingImage",
-			option: SquashedScope,
-			err:    true,
-		},
-		{
-			name:   "MissingSquashedTree",
-			option: SquashedScope,
-			img:    image.NewImage(nil),
-			err:    true,
-		},
-		{
-			name:   "NoLayers",
-			option: AllLayersScope,
-			img:    image.NewImage(nil),
-			err:    true,
-		},
-	}
-
-	for _, c := range cases {
-		actual, err := NewScope(c.img, c.option)
-		if err == nil && c.err {
-			t.Fatal("expected an error but did not find one")
-		} else if err != nil && !c.err {
-			t.Fatal("expected no error but found one:", err)
-		}
-
-		if len(actual.Trees) != len(c.expectedTrees) {
-			t.Fatalf("mismatched tree lengths: %d!=%d", len(actual.Trees), len(c.expectedTrees))
-		}
-
-		for idx, atr := range actual.Trees {
-			at, ok := atr.(*tree.FileTree)
-			if !ok {
-				t.Fatalf("could not extract tree from reader")
-			}
-			if !at.Equal(c.expectedTrees[idx]) {
-				t.Error("mismatched tree @ idx", idx)
-			}
-		}
-	}
-
-}