Follow convention for naming catalogers (#2277)

* follow convention for naming catalogers Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> * fix cataloger name example Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> --------- Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
2026-11-02 15:36:41 +01:00 · 2023-11-02 12:39:42 +00:00
parent 6c41f15975
commit b2f4d7eda2
144 changed files with 294 additions and 273 deletions
@@ -0,0 +1,15 @@
+/*
+Package arch provides a concrete Cataloger implementations for packages relating to the Arch linux distribution.
+*/
+package arch
+
+import (
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/pkg/cataloger/generic"
+)
+
+// NewDBCataloger returns a new cataloger object initialized for arch linux pacman database flat-file stores.
+func NewDBCataloger() *generic.Cataloger {
+	return generic.NewCataloger("alpm-db-cataloger").
+		WithParserByGlobs(parseAlpmDB, pkg.AlpmDBGlob)
+}
@@ -0,0 +1,209 @@
+package arch
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"github.com/anchore/syft/syft/artifact"
+	"github.com/anchore/syft/syft/file"
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/pkg/cataloger/internal/pkgtest"
+)
+
+func TestAlpmCataloger(t *testing.T) {
+	dbLocation := file.NewLocation("var/lib/pacman/local/gmp-6.2.1-2/desc")
+	expectedPkgs := []pkg.Package{
+		{
+			Name:    "gmp",
+			Version: "6.2.1-2",
+			Type:    pkg.AlpmPkg,
+			FoundBy: "alpm-db-cataloger",
+			Licenses: pkg.NewLicenseSet(
+				pkg.NewLicenseFromLocations("LGPL3", dbLocation),
+				pkg.NewLicenseFromLocations("GPL", dbLocation),
+			),
+			Locations: file.NewLocationSet(dbLocation),
+			CPEs:      nil,
+			PURL:      "",
+			Metadata: pkg.AlpmDBEntry{
+				BasePackage:  "gmp",
+				Package:      "gmp",
+				Version:      "6.2.1-2",
+				Description:  "A free library for arbitrary precision arithmetic",
+				Architecture: "x86_64",
+				Size:         1044438,
+				Packager:     "Antonio Rojas <arojas@archlinux.org>",
+				URL:          "https://gmplib.org/",
+				Validation:   "pgp",
+				Reason:       1,
+				Files: []pkg.AlpmFileRecord{
+					{
+						Path:    "/usr",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path:    "/usr/include",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path: "/usr/include/gmp.h",
+						Size: "84140",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "76595f70565c72550eb520809bf86856"},
+							{Algorithm: "sha256", Value: "91a614b9202453153fe3b7512d15e89659108b93ce8841c8e13789eb85da9e3a"},
+						},
+					},
+					{
+						Path: "/usr/include/gmpxx.h",
+						Size: "129113",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "ea3d21de4bcf7c696799c5c55dd3655b"},
+							{Algorithm: "sha256", Value: "0011ae411a0bc1030e07d968b32fdc1343f5ac2a17b7d28f493e7976dde2ac82"},
+						},
+					},
+					{
+						Path:    "/usr/lib",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path:    "/usr/lib/libgmp.so",
+						Type:    "link",
+						Link:    "libgmp.so.10.4.1",
+						Digests: []file.Digest{},
+					},
+					{
+						Path:    "/usr/lib/libgmp.so.10",
+						Type:    "link",
+						Link:    "libgmp.so.10.4.1",
+						Digests: []file.Digest{},
+					},
+					{
+						Path: "/usr/lib/libgmp.so.10.4.1",
+						Size: "663224",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "d6d03eadacdd9048d5b2adf577e9d722"},
+							{Algorithm: "sha256", Value: "39898bd3d8d6785222432fa8b8aef7ce3b7e5bbfc66a52b7c0da09bed4adbe6a"},
+						},
+					},
+					{
+						Path:    "/usr/lib/libgmpxx.so",
+						Type:    "link",
+						Link:    "libgmpxx.so.4.6.1",
+						Digests: []file.Digest{},
+					},
+					{
+						Path:    "/usr/lib/libgmpxx.so.4",
+						Type:    "link",
+						Link:    "libgmpxx.so.4.6.1",
+						Digests: []file.Digest{},
+					},
+					{
+						Path: "/usr/lib/libgmpxx.so.4.6.1",
+						Size: "30680",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "dd5f0c4d635fa599fa7f4339c0e8814d"},
+							{Algorithm: "sha256", Value: "0ef67cbde4841f58d2e4b41f59425eb87c9eeaf4e649c060b326342c53bedbec"},
+						},
+					},
+					{
+						Path:    "/usr/lib/pkgconfig",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path: "/usr/lib/pkgconfig/gmp.pc",
+						Size: "245",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "a91a9f1b66218cb77b9cd2cdf341756d"},
+							{Algorithm: "sha256", Value: "4e9de547a48c4e443781e9fa702a1ec5a23ee28b4bc520306cff2541a855be37"},
+						},
+					},
+					{
+						Path: "/usr/lib/pkgconfig/gmpxx.pc",
+						Size: "280",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "8c0f54e987934352177a6a30a811b001"},
+							{Algorithm: "sha256", Value: "fc5dbfbe75977057ba50953d94b9daecf696c9fdfe5b94692b832b44ecca871b"},
+						},
+					},
+					{
+						Path:    "/usr/share",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path:    "/usr/share/info",
+						Type:    "dir",
+						Digests: []file.Digest{},
+					},
+					{
+						Path: "/usr/share/info/gmp.info-1.gz",
+						Size: "85892",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "63304d4d2f0247fb8a999fae66a81c19"},
+							{Algorithm: "sha256", Value: "86288c1531a2789db5da8b9838b5cde4db07bda230ae11eba23a1f33698bd14e"},
+						},
+					},
+					{
+						Path: "/usr/share/info/gmp.info-2.gz",
+						Size: "48484",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "4bb0dadec416d305232cac6eae712ff7"},
+							{Algorithm: "sha256", Value: "b7443c1b529588d98a074266087f79b595657ac7274191c34b10a9ceedfa950e"},
+						},
+					},
+					{
+						Path: "/usr/share/info/gmp.info.gz",
+						Size: "2380",
+						Digests: []file.Digest{
+							{Algorithm: "md5", Value: "cf6880fb0d862ee1da0d13c3831b5720"},
+							{Algorithm: "sha256", Value: "a13c8eecda3f3e5ad1e09773e47a9686f07d9d494eaddf326f3696bbef1548fd"},
+						},
+					},
+				},
+				Backup: []pkg.AlpmFileRecord{},
+			},
+		},
+	}
+
+	// TODO: relationships are not under test yet
+	var expectedRelationships []artifact.Relationship
+
+	pkgtest.NewCatalogTester().
+		FromDirectory(t, "test-fixtures/gmp-fixture").
+		WithCompareOptions(cmpopts.IgnoreFields(pkg.AlpmFileRecord{}, "Time")).
+		Expects(expectedPkgs, expectedRelationships).
+		TestCataloger(t, NewDBCataloger())
+
+}
+
+func TestCataloger_Globs(t *testing.T) {
+	tests := []struct {
+		name     string
+		fixture  string
+		expected []string
+	}{
+		{
+			name:    "obtain description files",
+			fixture: "test-fixtures/glob-paths",
+			expected: []string{
+				"var/lib/pacman/local/base-1.0/desc",
+				"var/lib/pacman/local/dive-0.10.0/desc",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			pkgtest.NewCatalogTester().
+				FromDirectory(t, test.fixture).
+				ExpectsResolverContentQueries(test.expected).
+				IgnoreUnfulfilledPathResponses("var/lib/pacman/local/base-1.0/mtree", "var/lib/pacman/local/dive-0.10.0/mtree").
+				TestCataloger(t, NewDBCataloger())
+		})
+	}
+}
@@ -0,0 +1,54 @@
+package arch
+
+import (
+	"strings"
+
+	"github.com/anchore/packageurl-go"
+	"github.com/anchore/syft/syft/file"
+	"github.com/anchore/syft/syft/linux"
+	"github.com/anchore/syft/syft/pkg"
+)
+
+func newPackage(m *parsedData, release *linux.Release, dbLocation file.Location) pkg.Package {
+	licenseCandidates := strings.Split(m.Licenses, "\n")
+
+	p := pkg.Package{
+		Name:      m.Package,
+		Version:   m.Version,
+		Locations: file.NewLocationSet(dbLocation),
+		Licenses:  pkg.NewLicenseSet(pkg.NewLicensesFromLocation(dbLocation.WithoutAnnotations(), licenseCandidates...)...),
+		Type:      pkg.AlpmPkg,
+		PURL:      packageURL(m, release),
+		Metadata:  m.AlpmDBEntry,
+	}
+	p.SetID()
+
+	return p
+}
+
+func packageURL(m *parsedData, distro *linux.Release) string {
+	if distro == nil || distro.ID != "arch" {
+		// note: there is no namespace variation (like with debian ID_LIKE for ubuntu ID, for example)
+		return ""
+	}
+
+	qualifiers := map[string]string{
+		pkg.PURLQualifierArch: m.Architecture,
+	}
+
+	if m.BasePackage != "" {
+		qualifiers[pkg.PURLQualifierUpstream] = m.BasePackage
+	}
+
+	return packageurl.NewPackageURL(
+		"alpm", // `alpm` for Arch Linux and other users of the libalpm/pacman package manager. (see https://github.com/package-url/purl-spec/pull/164)
+		distro.ID,
+		m.Package,
+		m.Version,
+		pkg.PURLQualifiers(
+			qualifiers,
+			distro,
+		),
+		"",
+	).ToString()
+}
@@ -0,0 +1,150 @@
+package arch
+
+import (
+	"testing"
+
+	"github.com/sergi/go-diff/diffmatchpatch"
+
+	"github.com/anchore/packageurl-go"
+	"github.com/anchore/syft/syft/linux"
+	"github.com/anchore/syft/syft/pkg"
+)
+
+func Test_PackageURL(t *testing.T) {
+	tests := []struct {
+		name     string
+		metadata *parsedData
+		distro   linux.Release
+		expected string
+	}{
+		{
+			name: "bad distro id",
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package:      "p",
+					Version:      "v",
+					Architecture: "a",
+				},
+			},
+			distro: linux.Release{
+				ID:      "something-else",
+				BuildID: "rolling",
+			},
+			expected: "",
+		},
+		{
+			name: "gocase",
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package:      "p",
+					Version:      "v",
+					Architecture: "a",
+				},
+			},
+			distro: linux.Release{
+				ID:      "arch",
+				BuildID: "rolling",
+			},
+			expected: "pkg:alpm/arch/p@v?arch=a&distro=arch-rolling",
+		},
+		{
+			name: "missing architecture",
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package: "p",
+					Version: "v",
+				},
+			},
+			distro: linux.Release{
+				ID: "arch",
+			},
+			expected: "pkg:alpm/arch/p@v?distro=arch",
+		},
+		{
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package:      "python",
+					Version:      "3.10.0",
+					Architecture: "any",
+				},
+			},
+			distro: linux.Release{
+				ID:      "arch",
+				BuildID: "rolling",
+			},
+			expected: "pkg:alpm/arch/python@3.10.0?arch=any&distro=arch-rolling",
+		},
+		{
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package:      "g plus plus",
+					Version:      "v84",
+					Architecture: "x86_64",
+				},
+			},
+			distro: linux.Release{
+				ID:      "arch",
+				BuildID: "rolling",
+			},
+			expected: "pkg:alpm/arch/g%20plus%20plus@v84?arch=x86_64&distro=arch-rolling",
+		},
+		{
+			name: "add source information as qualifier",
+			metadata: &parsedData{
+				Licenses: "",
+				AlpmDBEntry: pkg.AlpmDBEntry{
+					Package:      "p",
+					Version:      "v",
+					Architecture: "a",
+					BasePackage:  "origin",
+				},
+			},
+			distro: linux.Release{
+				ID:      "arch",
+				BuildID: "rolling",
+			},
+			expected: "pkg:alpm/arch/p@v?arch=a&upstream=origin&distro=arch-rolling",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			actual := packageURL(test.metadata, &test.distro)
+			if actual != test.expected {
+				dmp := diffmatchpatch.New()
+				diffs := dmp.DiffMain(test.expected, actual, true)
+				t.Errorf("diff: %s", dmp.DiffPrettyText(diffs))
+			}
+
+			if test.expected == "" {
+				return
+			}
+
+			// verify packageurl can parse
+			purl, err := packageurl.FromString(actual)
+			if err != nil {
+				t.Errorf("cannot re-parse purl: %s", actual)
+			}
+			if purl.Name != test.metadata.Package {
+				dmp := diffmatchpatch.New()
+				diffs := dmp.DiffMain(test.metadata.Package, purl.Name, true)
+				t.Errorf("invalid purl name: %s", dmp.DiffPrettyText(diffs))
+			}
+			if purl.Version != test.metadata.Version {
+				dmp := diffmatchpatch.New()
+				diffs := dmp.DiffMain(test.metadata.Version, purl.Version, true)
+				t.Errorf("invalid purl version: %s", dmp.DiffPrettyText(diffs))
+			}
+			if purl.Qualifiers.Map()["arch"] != test.metadata.Architecture {
+				dmp := diffmatchpatch.New()
+				diffs := dmp.DiffMain(test.metadata.Architecture, purl.Qualifiers.Map()["arch"], true)
+				t.Errorf("invalid purl architecture: %s", dmp.DiffPrettyText(diffs))
+			}
+		})
+	}
+}
@@ -0,0 +1,259 @@
+package arch
+
+import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/vbatts/go-mtree"
+
+	"github.com/anchore/syft/syft/artifact"
+	"github.com/anchore/syft/syft/file"
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/pkg/cataloger/generic"
+)
+
+var _ generic.Parser = parseAlpmDB
+
+var (
+	ignoredFiles = map[string]bool{
+		"/set":       true,
+		".BUILDINFO": true,
+		".PKGINFO":   true,
+		"":           true,
+	}
+)
+
+type parsedData struct {
+	Licenses        string `mapstructure:"license"`
+	pkg.AlpmDBEntry `mapstructure:",squash"`
+}
+
+// parseAlpmDB parses the arch linux pacman database flat-files and returns the packages and relationships found within.
+func parseAlpmDB(resolver file.Resolver, env *generic.Environment, reader file.LocationReadCloser) ([]pkg.Package, []artifact.Relationship, error) {
+	data, err := parseAlpmDBEntry(reader)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	base := filepath.Dir(reader.RealPath)
+	r, err := getFileReader(filepath.Join(base, "mtree"), resolver)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	pkgFiles, err := parseMtree(r)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// replace the files found the pacman database with the files from the mtree These contain more metadata and
+	// thus more useful.
+	// TODO: probably want to use MTREE and PKGINFO here
+	data.Files = pkgFiles
+
+	// We only really do this to get any backup database entries from the files database
+	files := filepath.Join(base, "files")
+	_, err = getFileReader(files, resolver)
+	if err != nil {
+		return nil, nil, err
+	}
+	filesMetadata, err := parseAlpmDBEntry(reader)
+	if err != nil {
+		return nil, nil, err
+	} else if filesMetadata != nil {
+		data.Backup = filesMetadata.Backup
+	}
+
+	if data.Package == "" {
+		return nil, nil, nil
+	}
+
+	return []pkg.Package{
+		newPackage(
+			data,
+			env.LinuxRelease,
+			reader.Location.WithAnnotation(pkg.EvidenceAnnotationKey, pkg.PrimaryEvidenceAnnotation),
+		),
+	}, nil, nil
+}
+
+func parseAlpmDBEntry(reader io.Reader) (*parsedData, error) {
+	scanner := newScanner(reader)
+	metadata, err := parseDatabase(scanner)
+	if err != nil {
+		return nil, err
+	}
+	return metadata, nil
+}
+
+func newScanner(reader io.Reader) *bufio.Scanner {
+	// This is taken from the apk parser
+	// https://github.com/anchore/syft/blob/v0.47.0/syft/pkg/cataloger/apkdb/parse_apk_db.go#L37
+	const maxScannerCapacity = 1024 * 1024
+	bufScan := make([]byte, maxScannerCapacity)
+	scanner := bufio.NewScanner(reader)
+	scanner.Buffer(bufScan, maxScannerCapacity)
+	onDoubleLF := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		for i := 0; i < len(data); i++ {
+			if i > 0 && data[i-1] == '\n' && data[i] == '\n' {
+				return i + 1, data[:i-1], nil
+			}
+		}
+		if !atEOF {
+			return 0, nil, nil
+		}
+		// deliver the last token (which could be an empty string)
+		return 0, data, bufio.ErrFinalToken
+	}
+
+	scanner.Split(onDoubleLF)
+	return scanner
+}
+
+func getFileReader(path string, resolver file.Resolver) (io.Reader, error) {
+	locs, err := resolver.FilesByPath(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(locs) == 0 {
+		return nil, fmt.Errorf("could not find file: %s", path)
+	}
+	// TODO: Should we maybe check if we found the file
+	dbContentReader, err := resolver.FileContentsByLocation(locs[0])
+	if err != nil {
+		return nil, err
+	}
+	return dbContentReader, nil
+}
+
+func parseDatabase(b *bufio.Scanner) (*parsedData, error) {
+	var err error
+	pkgFields := make(map[string]interface{})
+	for b.Scan() {
+		fields := strings.SplitN(b.Text(), "\n", 2)
+
+		// End of File
+		if len(fields) == 1 {
+			break
+		}
+
+		// The alpm database surrounds the keys with %.
+		key := strings.ReplaceAll(fields[0], "%", "")
+		key = strings.ToLower(key)
+		value := strings.TrimSpace(fields[1])
+
+		switch key {
+		case "files":
+			var files []map[string]string
+			for _, f := range strings.Split(value, "\n") {
+				path := fmt.Sprintf("/%s", f)
+				if ok := ignoredFiles[path]; !ok {
+					files = append(files, map[string]string{"path": path})
+				}
+			}
+			pkgFields[key] = files
+		case "backup":
+			var backup []map[string]interface{}
+			for _, f := range strings.Split(value, "\n") {
+				fields := strings.SplitN(f, "\t", 2)
+				path := fmt.Sprintf("/%s", fields[0])
+				if ok := ignoredFiles[path]; !ok {
+					backup = append(backup, map[string]interface{}{
+						"path": path,
+						"digests": []file.Digest{{
+							Algorithm: "md5",
+							Value:     fields[1],
+						}}})
+				}
+			}
+			pkgFields[key] = backup
+		case "reason":
+			fallthrough
+		case "size":
+			pkgFields[key], err = strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse %s to integer", value)
+			}
+		default:
+			pkgFields[key] = value
+		}
+	}
+
+	return parsePkgFiles(pkgFields)
+}
+
+func parsePkgFiles(pkgFields map[string]interface{}) (*parsedData, error) {
+	var entry parsedData
+	if err := mapstructure.Decode(pkgFields, &entry); err != nil {
+		return nil, fmt.Errorf("unable to parse ALPM metadata: %w", err)
+	}
+
+	if entry.Backup == nil {
+		entry.Backup = make([]pkg.AlpmFileRecord, 0)
+	}
+
+	if entry.Package == "" && len(entry.Files) == 0 && len(entry.Backup) == 0 {
+		return nil, nil
+	}
+	return &entry, nil
+}
+
+func parseMtree(r io.Reader) ([]pkg.AlpmFileRecord, error) {
+	var err error
+	var entries []pkg.AlpmFileRecord
+
+	r, err = gzip.NewReader(r)
+	if err != nil {
+		return nil, err
+	}
+	specDh, err := mtree.ParseSpec(r)
+	if err != nil {
+		return nil, err
+	}
+	for _, f := range specDh.Entries {
+		var entry pkg.AlpmFileRecord
+		entry.Digests = make([]file.Digest, 0)
+		fileFields := make(map[string]interface{})
+		if ok := ignoredFiles[f.Name]; ok {
+			continue
+		}
+		path := fmt.Sprintf("/%s", f.Name)
+		fileFields["path"] = path
+		for _, kv := range f.Keywords {
+			kw := string(kv.Keyword())
+			switch kw {
+			case "time":
+				// All unix timestamps have a .0 suffixs.
+				v := strings.Split(kv.Value(), ".")
+				i, _ := strconv.ParseInt(v[0], 10, 64)
+				tm := time.Unix(i, 0)
+				fileFields[kw] = tm
+			case "sha256digest":
+				entry.Digests = append(entry.Digests, file.Digest{
+					Algorithm: "sha256",
+					Value:     kv.Value(),
+				})
+			case "md5digest":
+				entry.Digests = append(entry.Digests, file.Digest{
+					Algorithm: "md5",
+					Value:     kv.Value(),
+				})
+			default:
+				fileFields[kw] = kv.Value()
+			}
+		}
+		if err := mapstructure.Decode(fileFields, &entry); err != nil {
+			return nil, fmt.Errorf("unable to parse ALPM mtree data: %w", err)
+		}
+		entries = append(entries, entry)
+	}
+	return entries, nil
+}
@@ -0,0 +1,176 @@
+package arch
+
+import (
+	"bufio"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stretchr/testify/require"
+
+	"github.com/anchore/syft/syft/file"
+	"github.com/anchore/syft/syft/pkg"
+)
+
+func TestDatabaseParser(t *testing.T) {
+	tests := []struct {
+		name     string
+		fixture  string
+		expected pkg.AlpmDBEntry
+	}{
+		{
+			name:    "test alpm database parsing",
+			fixture: "test-fixtures/files",
+			expected: pkg.AlpmDBEntry{
+				Backup: []pkg.AlpmFileRecord{
+					{
+						Path: "/etc/pacman.conf",
+						Digests: []file.Digest{{
+							Algorithm: "md5",
+							Value:     "de541390e52468165b96511c4665bff4",
+						}},
+					},
+					{
+						Path: "/etc/makepkg.conf",
+						Digests: []file.Digest{{
+							Algorithm: "md5",
+							Value:     "79fce043df7dfc676ae5ecb903762d8b",
+						}},
+					},
+				},
+				Files: []pkg.AlpmFileRecord{
+					{
+						Path: "/etc/",
+					},
+					{
+						Path: "/etc/makepkg.conf",
+					},
+					{
+						Path: "/etc/pacman.conf",
+					},
+					{
+						Path: "/usr/",
+					},
+					{
+						Path: "/usr/bin/",
+					},
+					{
+						Path: "/usr/bin/makepkg",
+					},
+					{
+						Path: "/usr/bin/makepkg-template",
+					},
+					{
+						Path: "/usr/bin/pacman",
+					},
+					{
+						Path: "/usr/bin/pacman-conf",
+					},
+					{
+						Path: "/var/",
+					},
+					{
+						Path: "/var/cache/",
+					},
+					{
+						Path: "/var/cache/pacman/",
+					},
+					{
+						Path: "/var/cache/pacman/pkg/",
+					},
+					{
+						Path: "/var/lib/",
+					},
+					{
+						Path: "/var/lib/pacman/",
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			f, err := os.Open(test.fixture)
+			require.NoError(t, err)
+			t.Cleanup(func() { require.NoError(t, f.Close()) })
+
+			reader := bufio.NewReader(f)
+
+			entry, err := parseAlpmDBEntry(reader)
+			require.NoError(t, err)
+
+			if diff := cmp.Diff(entry.Files, test.expected.Files); diff != "" {
+				t.Errorf("Files mismatch (-want +got):\n%s", diff)
+			}
+
+			if diff := cmp.Diff(entry.Backup, test.expected.Backup); diff != "" {
+				t.Errorf("Backup mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func parseTime(stime string) time.Time {
+	t, _ := time.Parse(time.RFC3339, stime)
+	return t
+}
+
+func TestMtreeParse(t *testing.T) {
+	tests := []struct {
+		name     string
+		expected []pkg.AlpmFileRecord
+	}{
+		{
+			name: "test mtree parsing",
+			expected: []pkg.AlpmFileRecord{
+				{
+					Path:    "/etc",
+					Type:    "dir",
+					Time:    parseTime("2022-04-10T14:59:52+02:00"),
+					Digests: make([]file.Digest, 0),
+				},
+				{
+					Path:    "/etc/pacman.d",
+					Type:    "dir",
+					Time:    parseTime("2022-04-10T14:59:52+02:00"),
+					Digests: make([]file.Digest, 0),
+				},
+				{
+					Path: "/etc/pacman.d/mirrorlist",
+					Size: "44683",
+					Time: parseTime("2022-04-10T14:59:52+02:00"),
+					Digests: []file.Digest{
+						{
+							Algorithm: "md5",
+							Value:     "81c39827e38c759d7e847f05db62c233",
+						},
+						{
+							Algorithm: "sha256",
+							Value:     "fc135ab26f2a227b9599b66a2f1ba325c445acb914d60e7ecf6e5997a87abe1e",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			f, err := os.Open("test-fixtures/mtree")
+			require.NoError(t, err)
+			t.Cleanup(func() { require.NoError(t, f.Close()) })
+
+			reader := bufio.NewReader(f)
+
+			entry, err := parseMtree(reader)
+			require.NoError(t, err)
+
+			if diff := cmp.Diff(entry, test.expected); diff != "" {
+				t.Errorf("Files mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+
+}
@@ -0,0 +1,20 @@
+%FILES%
+etc/
+etc/makepkg.conf
+etc/pacman.conf
+usr/
+usr/bin/
+usr/bin/makepkg
+usr/bin/makepkg-template
+usr/bin/pacman
+usr/bin/pacman-conf
+var/
+var/cache/
+var/cache/pacman/
+var/cache/pacman/pkg/
+var/lib/
+var/lib/pacman/
+
+%BACKUP%
+etc/pacman.conf	de541390e52468165b96511c4665bff4
+etc/makepkg.conf	79fce043df7dfc676ae5ecb903762d8b
@@ -0,0 +1 @@
+bogus desc file
@@ -0,0 +1 @@
+bogus files
@@ -0,0 +1 @@
+bogus desc file
@@ -0,0 +1,44 @@
+%NAME%
+gmp
+
+%VERSION%
+6.2.1-2
+
+%BASE%
+gmp
+
+%DESC%
+A free library for arbitrary precision arithmetic
+
+%URL%
+https://gmplib.org/
+
+%ARCH%
+x86_64
+
+%BUILDDATE%
+1653121258
+
+%INSTALLDATE%
+1665878640
+
+%PACKAGER%
+Antonio Rojas <arojas@archlinux.org>
+
+%SIZE%
+1044438
+
+%REASON%
+1
+
+%LICENSE%
+LGPL3
+GPL
+
+%VALIDATION%
+pgp
+
+%DEPENDS%
+gcc-libs
+sh
+
@@ -0,0 +1,21 @@
+%FILES%
+usr/
+usr/include/
+usr/include/gmp.h
+usr/include/gmpxx.h
+usr/lib/
+usr/lib/libgmp.so
+usr/lib/libgmp.so.10
+usr/lib/libgmp.so.10.4.1
+usr/lib/libgmpxx.so
+usr/lib/libgmpxx.so.4
+usr/lib/libgmpxx.so.4.6.1
+usr/lib/pkgconfig/
+usr/lib/pkgconfig/gmp.pc
+usr/lib/pkgconfig/gmpxx.pc
+usr/share/
+usr/share/info/
+usr/share/info/gmp.info-1.gz
+usr/share/info/gmp.info-2.gz
+usr/share/info/gmp.info.gz
+