diff --git a/go.mod b/go.mod index dacc59077..ef3340784 100644 --- a/go.mod +++ b/go.mod @@ -1,8 +1,8 @@ module github.com/quay/claircore -go 1.23.0 +go 1.24.0 -toolchain go1.24.1 +toolchain go1.24.3 require ( github.com/Masterminds/semver v1.5.0 diff --git a/gobin/gobin.go b/gobin/gobin.go index 47459e46e..91aad4456 100644 --- a/gobin/gobin.go +++ b/gobin/gobin.go @@ -84,7 +84,7 @@ func (Detector) Scan(ctx context.Context, l *claircore.Layer) ([]*claircore.Pack // // Only create a single spool file per call, re-use for every binary. var spool spoolfile - fc, err := rpm.NewFileChecker(ctx, l) + set, err := rpm.NewPathSet(ctx, l) if err != nil { return nil, fmt.Errorf("gobin: unable to check RPM db: %w", err) } @@ -113,7 +113,7 @@ func (Detector) Scan(ctx context.Context, l *claircore.Layer) ([]*claircore.Pack return nil } - if fc.IsRPM(p) { + if set.Contains(p) { zlog.Debug(ctx). Str("path", p). Msg("file path determined to be of RPM origin") diff --git a/internal/dnf/dnf.go b/internal/dnf/dnf.go new file mode 100644 index 000000000..0823e74e3 --- /dev/null +++ b/internal/dnf/dnf.go @@ -0,0 +1,274 @@ +// Package dnf interfaces with dnf 4 and 5 history databases to extract repoid +// information. +// +// This package tries to use "repoid" when referring to a dnf repository's ID, +// to help distinguish it from a [claircore.Repository] ID. +package dnf // import "github.com/quay/claircore/internal/dnf" + +import ( + "context" + "database/sql" + "errors" + "fmt" + "io" + "io/fs" + "iter" + "net/url" + "os" + "runtime" + "slices" + + "github.com/quay/zlog" + _ "modernc.org/sqlite" // register the sqlite driver + + "github.com/quay/claircore" + "github.com/quay/claircore/internal/rpmver" +) + +// BUG(hank) The dnf mapping is less useful than it could be because there's no +// reliable way to turn the "repoid" that it reports into something with meaning +// outside of the Red Hat build system's builder's context. See [CLAIRDEV-45] +// for more information. +// +// [CLAIRDEV-45]: https://issues.redhat.com/browse/CLAIRDEV-45 + +// PackageSeq is an alias for the Package iterator type. +type PackageSeq = iter.Seq2[claircore.Package, error] + +// Wrap closes over the passed [fs.FS] and [PackageSeq] and returns a +// [PackageSeq] that annotates the [claircore.Package]s with the dnf repoid. +func Wrap(ctx context.Context, sys fs.FS, seq PackageSeq) (PackageSeq, error) { + h, err := openHistoryDB(ctx, sys) + if err != nil { + return nil, err + } + + wrapped := func(yield func(claircore.Package, error) bool) { + defer h.Close() + + for pkg, err := range seq { + if err != nil { + if !yield(pkg, err) { + return + } + continue + } + + err = h.AddRepoid(ctx, &pkg) + if !yield(pkg, err) { + return + } + } + } + return wrapped, nil +} + +// FindRepoids reports all the repoids discovered in the dnf history database in +// the provided [fs.FS]. +func FindRepoids(ctx context.Context, sys fs.FS) ([]string, error) { + h, err := openHistoryDB(ctx, sys) + if err != nil { + return nil, err + } + if h == nil { + return nil, nil + } + defer h.Close() + + var ret []string + rows, err := h.db.QueryContext(ctx, allRepoids, h.rm) + if err != nil { + return nil, err + } + defer func() { + if err := rows.Close(); err != nil { + zlog.Warn(ctx).Err(err).Msg("error closing returned rows") + } + }() + + for rows.Next() { + var id string + if err := rows.Scan(&id); err != nil { + return nil, fmt.Errorf("internal/dnf: error scanning repoid: %w", err) + } + ret = append(ret, id) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("internal/dnf: error reading rows: %w", err) + } + + return ret, nil +} + +// DbDesc describes the path to a dnf history database and the enum used to +// denote a "removed" action. +type dbDesc struct { + Path string + Enum int +} + +// Possible is the slice of dbDesc that's examined by openHistoryDB. +var possible = []dbDesc{ + { // dnf5 + // https://github.com/rpm-software-management/dnf5/blob/5.2.13.0/libdnf5/transaction/db/db.cpp#L78-L89 + Path: `usr/lib/sysimage/libdnf5/transaction_history.sqlite`, + // https://github.com/rpm-software-management/dnf5/blob/5.2.13.0/include/libdnf5/transaction/transaction_item_action.hpp#L42 + Enum: 5, + }, + { // dnf3/4 + // https://github.com/rpm-software-management/libdnf/blob/4.90/libdnf/transaction/Swdb.hpp#L57 + Path: `var/lib/dnf/history.sqlite`, + // https://github.com/rpm-software-management/libdnf/blob/4.90/libdnf/transaction/Types.hpp#L53 + Enum: 8, + }, +} + +// HistoryDB is a handle to the dnf history database. +// +// All methods are safe to call on a nil receiver. +type historyDB struct { + db *sql.DB + rm int +} + +// OpenHistoryDB does what it says on the tin. +// +// This function may return a nil *historyDB, which is still safe to use. +func openHistoryDB(ctx context.Context, sys fs.FS) (*historyDB, error) { + var found *dbDesc +Stat: + for _, v := range possible { + switch _, err := fs.Stat(sys, v.Path); { + case errors.Is(err, nil): + found = &v + break Stat + case errors.Is(err, fs.ErrNotExist): // OK + default: + return nil, fmt.Errorf("internal/dnf: unexpected error handling fs.FS: %w", err) + } + } + if found == nil { + return nil, nil + } + var h *historyDB + + f, err := sys.Open(found.Path) + if err != nil { + return nil, fmt.Errorf("internal/dnf: unexpected error opening history: %w", err) + } + defer func() { + if err := f.Close(); err != nil { + zlog.Warn(ctx).Err(err).Msg("unable to close fs.FS db file") + } + }() + + // Needs to be linked into the filesystem for the sqlite driver to open it. + // See also: quay/claircore#720 + spool, err := os.CreateTemp(os.TempDir(), `dnf.sqlite.*`) + if err != nil { + return nil, fmt.Errorf("internal/dnf: error reading sqlite db: %w", err) + } + defer func() { + if err := spool.Close(); err != nil { + zlog.Warn(ctx).Err(err).Msg("unable to close sqlite db file") + } + // If in an error return, make sure to clean up the spool file. + if h == nil { + if err := os.Remove(spool.Name()); err != nil { + zlog.Warn(ctx).Err(err).Msg("unable to unlink sqlite db file") + } + } + }() + + zlog.Debug(ctx).Str("file", spool.Name()).Msg("copying sqlite db out of tar") + if _, err := io.Copy(spool, f); err != nil { + return nil, fmt.Errorf("internal/dnf: error spooling sqlite db: %w", err) + } + if err := spool.Sync(); err != nil { + return nil, fmt.Errorf("internal/dnf: error spooling sqlite db: %w", err) + } + + db, err := sql.Open("sqlite", spool.Name()) + if err != nil { + return nil, fmt.Errorf("internal/dnf: error reading sqlite db: %w", err) + } + if err := db.PingContext(ctx); err != nil { + return nil, fmt.Errorf("internal/dnf: error reading sqlite db: %w", err) + } + + h = &historyDB{ + db: db, + rm: found.Enum, + } + // This is an internal function, so add an extra caller frame. + _, file, line, _ := runtime.Caller(2) + runtime.SetFinalizer(h, func(_ *historyDB) { + panic(fmt.Sprintf("%s:%d: historyDB not closed", file, line)) + }) + return h, nil +} + +// AddRepoid modifies the passed [claircore.Package] with a discovered dnf +// repoid, if possible. +// +// If any error is reported, the [claircore.Package] value is not modified. +func (h *historyDB) AddRepoid(ctx context.Context, pkg *claircore.Package) error { + if h == nil { + return nil + } + + // TODO(hank) Shouldn't need to build a string like this. + v := fmt.Sprintf("%s-%s.%s", pkg.Name, pkg.Version, pkg.Arch) // "Version" contains the EVR. + ver, err := rpmver.Parse(v) + if err != nil { + zlog.Warn(ctx). + Err(err). + Str("version", v). + Msg("unable to re-parse rpm version") + return nil + } + + var id string + err = h.db. + QueryRowContext(ctx, repoidForPackage, h.rm, + *ver.Name, ver.Epoch, ver.Version, ver.Release, *ver.Architecture). + Scan(&id) + switch { + case err == nil: + case errors.Is(err, sql.ErrNoRows): + return nil + default: + return fmt.Errorf("internal/dnf: database error: %w", err) + } + + // Re-parse and edit the RepositoryHint. + // + // It's annoying to do this, a [claircore.Package] redesign should make sure + // to fix this wart where we need structured information in a string. + for _, pkg := range []*claircore.Package{pkg, pkg.Source} { + if pkg == nil { + continue + } + v, err := url.ParseQuery(pkg.RepositoryHint) + if err != nil { + return fmt.Errorf("internal/dnf: malformed RepositoryHint (%s: %#q): %w", + pkg.Name, pkg.RepositoryHint, err) + } + v.Add("repoid", id) + slices.Sort(v["repoid"]) + v["repoid"] = slices.Compact(v["repoid"]) + pkg.RepositoryHint = v.Encode() + } + + return nil +} + +// Close releases held resources. +func (h *historyDB) Close() error { + if h == nil { + return nil + } + + runtime.SetFinalizer(h, nil) + return h.db.Close() +} diff --git a/internal/dnf/dnf_test.go b/internal/dnf/dnf_test.go new file mode 100644 index 000000000..da27fcbfd --- /dev/null +++ b/internal/dnf/dnf_test.go @@ -0,0 +1,91 @@ +package dnf + +import ( + "context" + "io/fs" + "os" + "slices" + "testing" + + "github.com/google/go-cmp/cmp" + "github.com/quay/zlog" + + "github.com/quay/claircore" +) + +type testCase struct { + Name string + FS fs.FS + Package claircore.Package + Want string +} + +func (tc *testCase) Run(ctx context.Context, t *testing.T) { + t.Run(tc.Name, func(t *testing.T) { + ctx := zlog.Test(ctx, t) + seq := func(yield func(claircore.Package, error) bool) { + yield(tc.Package, nil) + } + wrapped, err := Wrap(ctx, tc.FS, seq) + if err != nil { + t.Errorf("error creating wrapper: %v", err) + } + + for p := range wrapped { + if got, want := p.RepositoryHint, tc.Want; got != want { + t.Errorf("incorrect repository hint: got: %q, want: %q", p.RepositoryHint, tc.Want) + } + } + }) +} + +func TestWrap(t *testing.T) { + ctx := zlog.Test(context.Background(), t) + sys := os.DirFS("testdata") + + tcs := []testCase{ + { + Name: "Found", + FS: sys, + Package: claircore.Package{ + Name: "apr-util-bdb", + Version: "1.6.1-23.el9", + Kind: claircore.BINARY, + Arch: "x86_64", + RepositoryHint: "something=nothing", + }, + Want: "repoid=rhel-9-for-x86_64-appstream-rpms&something=nothing", + }, + { + Name: "Absent", + FS: sys, + Package: claircore.Package{ + Name: "apr-util-bdb", + Version: "1.7.1-23.el9", // different version + Kind: claircore.BINARY, + Arch: "x86_64", + RepositoryHint: "something=nothing", + }, + Want: "something=nothing", + }, + } + for _, tc := range tcs { + tc.Run(ctx, t) + } +} + +func TestFindRepoids(t *testing.T) { + ctx := zlog.Test(context.Background(), t) + sys := os.DirFS("testdata") + + got, err := FindRepoids(ctx, sys) + if err != nil { + t.Errorf("error finding repoids: %v", err) + } + slices.Sort(got) + got = slices.Compact(got) + want := []string{"rhel-9-for-x86_64-appstream-rpms", "rhel-9-for-x86_64-baseos-rpms"} + if !cmp.Equal(got, want) { + t.Error(cmp.Diff(got, want)) + } +} diff --git a/internal/dnf/sql.go b/internal/dnf/sql.go new file mode 100644 index 000000000..ae20a67bf --- /dev/null +++ b/internal/dnf/sql.go @@ -0,0 +1,22 @@ +package dnf + +import _ "embed" // embed sql + +// Return one column containing the repoid. +// Takes six arguments, in order: +// - the "removed" enum +// - name +// - epoch +// - version +// - release +// - arch +// +//go:embed sql/repoid_for_package.sql +var repoidForPackage string + +// Return one column containing the repoids. +// Takes one argument: +// - the "removed" enum +// +//go:embed sql/all_repoids.sql +var allRepoids string diff --git a/internal/dnf/sql/all_repoids.sql b/internal/dnf/sql/all_repoids.sql new file mode 100644 index 000000000..2719c9862 --- /dev/null +++ b/internal/dnf/sql/all_repoids.sql @@ -0,0 +1,16 @@ +SELECT + repoid +FROM + trans_item + JOIN ( + SELECT + max(id) AS uniq + FROM + trans_item + WHERE + action <> ? + GROUP BY + item_id + ) ON (uniq = trans_item.id) + JOIN + repo ON (repo.id = repo_id); diff --git a/internal/dnf/sql/repoid_for_package.sql b/internal/dnf/sql/repoid_for_package.sql new file mode 100644 index 000000000..dcf54ae7a --- /dev/null +++ b/internal/dnf/sql/repoid_for_package.sql @@ -0,0 +1,28 @@ +SELECT + repoid +FROM + trans_item + JOIN ( + SELECT + max(id) AS uniq + FROM + trans_item + WHERE + action <> ? + GROUP BY + item_id + ) ON (uniq = trans_item.id) + JOIN + repo ON (repo.id = repo_id) + JOIN ( + SELECT + item_id + FROM + rpm + WHERE + name = ? AND + epoch = ? AND + version = ? AND + release = ? AND + arch = ? + ) USING (item_id); diff --git a/internal/dnf/testdata/var/lib/dnf/history.sqlite b/internal/dnf/testdata/var/lib/dnf/history.sqlite new file mode 100644 index 000000000..fca378ebd Binary files /dev/null and b/internal/dnf/testdata/var/lib/dnf/history.sqlite differ diff --git a/internal/rpm/assertions.go b/internal/rpm/assertions.go new file mode 100644 index 000000000..0000f8052 --- /dev/null +++ b/internal/rpm/assertions.go @@ -0,0 +1,14 @@ +package rpm + +import ( + "github.com/quay/claircore/internal/rpm/bdb" + "github.com/quay/claircore/internal/rpm/ndb" + "github.com/quay/claircore/internal/rpm/sqlite" +) + +// Assert that the various database-specific packages implement [HeaderReader]. +var ( + _ HeaderReader = (*sqlite.RPMDB)(nil) + _ HeaderReader = (*bdb.PackageDB)(nil) + _ HeaderReader = (*ndb.PackageDB)(nil) +) diff --git a/rpm/bdb/bdb.go b/internal/rpm/bdb/bdb.go similarity index 69% rename from rpm/bdb/bdb.go rename to internal/rpm/bdb/bdb.go index c8e2714fa..f5f42d095 100644 --- a/rpm/bdb/bdb.go +++ b/internal/rpm/bdb/bdb.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "io" + "iter" "github.com/quay/zlog" ) @@ -168,87 +169,107 @@ type hashoffpage struct { Length uint32 /* 08-11: Total length of item. */ } -// AllHeaders returns ReaderAts for all RPM headers in the PackageDB. -func (db *PackageDB) AllHeaders(ctx context.Context) ([]io.ReaderAt, error) { - var ret []io.ReaderAt +// Headers returns an iterator over all RPM headers in the PackageDB. +func (db *PackageDB) Headers(ctx context.Context) iter.Seq2[io.ReaderAt, error] { pageSz := int64(db.m.PageSize) - for n, lim := int64(0), int64(db.m.LastPageNo)+1; n < lim; n++ { - pg := io.NewSectionReader(db.r, n*pageSz, pageSz) - var h hashpage - if err := binary.Read(pg, db.ord, &h); err != nil { - return nil, fmt.Errorf("bdb: error reading hashpage: %w", err) - } - if h.Type != pagetypeHashUnsorted && h.Type != pagetypeHash { - continue - } - if h.Entries%2 != 0 { - return nil, errors.New("bdb: odd number of entries") - } - - ent := make([]hashentry, int(h.Entries)/2) - for i := range ent { - if err := binary.Read(pg, db.ord, &ent[i]); err != nil { - return nil, fmt.Errorf("bdb: error reading hash entry: %w", err) + return func(yield func(io.ReaderAt, error) bool) { + for n, lim := int64(0), int64(db.m.LastPageNo)+1; n < lim; n++ { + pg := io.NewSectionReader(db.r, n*pageSz, pageSz) + var h hashpage + if err := binary.Read(pg, db.ord, &h); err != nil { + if !yield(nil, fmt.Errorf("bdb: error reading hashpage: %w", err)) { + return + } + continue } - } - - k := []byte{0x00} - for _, e := range ent { - off := int64(e.Data) - // First, check what kind of hash entry this is. - view := io.NewSectionReader(pg, off, hashoffpageSize) - if _, err := view.ReadAt(k, 0); err != nil { - return nil, fmt.Errorf("bdb: error peeking page type: %w", err) + if h.Type != pagetypeHashUnsorted && h.Type != pagetypeHash { + continue } - if k[0] != pagetypeHashOffIndex { + if h.Entries%2 != 0 { + if !yield(nil, errors.New("bdb: odd number of entries")) { + return + } continue } - // Read the page header, now that we know it's correct. - var offpg hashoffpage - if err := binary.Read(view, db.ord, &offpg); err != nil { - return nil, fmt.Errorf("bdb: error reading hashoffpage: %w", err) + + ent := make([]hashentry, int(h.Entries)/2) + for i := range ent { + if err := binary.Read(pg, db.ord, &ent[i]); err != nil { + if !yield(nil, fmt.Errorf("bdb: error reading hash entry: %w", err)) { + return + } + continue + } } - var r rope - for n := offpg.PageNo; n != 0; { - off := pageSz * int64(n) - pg := io.NewSectionReader(db.r, off, pageSz) - var h hashpage - if err := binary.Read(pg, db.ord, &h); err != nil { - return nil, fmt.Errorf("bdb: error reading hashpage: %w", err) + + k := []byte{0x00} + Entry: + for _, e := range ent { + off := int64(e.Data) + // First, check what kind of hash entry this is. + view := io.NewSectionReader(pg, off, hashoffpageSize) + if _, err := view.ReadAt(k, 0); err != nil { + if !yield(nil, fmt.Errorf("bdb: error peeking page type: %w", err)) { + return + } + continue } - if h.Type != pagetypeOverflow { + if k[0] != pagetypeHashOffIndex { continue } - off += hashpageSize + // Read the page header, now that we know it's correct. + var offpg hashoffpage + if err := binary.Read(view, db.ord, &offpg); err != nil { + if !yield(nil, fmt.Errorf("bdb: error reading hashoffpage: %w", err)) { + return + } + continue + } + var r rope + for n := offpg.PageNo; n != 0; { + off := pageSz * int64(n) + pg := io.NewSectionReader(db.r, off, pageSz) + var h hashpage + if err := binary.Read(pg, db.ord, &h); err != nil { + if !yield(nil, fmt.Errorf("bdb: error reading hashpage: %w", err)) { + return + } + continue Entry + } + if h.Type != pagetypeOverflow { + continue + } + off += hashpageSize - var data *io.SectionReader - if h.NextPageNo == 0 { - // If this is the last page, only read to the end. - data = io.NewSectionReader(db.r, off, int64(h.HighFreeOffset)) - } else { - data = io.NewSectionReader(db.r, off, pageSz-hashpageSize) + var data *io.SectionReader + if h.NextPageNo == 0 { + // If this is the last page, only read to the end. + data = io.NewSectionReader(db.r, off, int64(h.HighFreeOffset)) + } else { + data = io.NewSectionReader(db.r, off, pageSz-hashpageSize) + } + if err := r.add(data); err != nil { + if !yield(nil, fmt.Errorf("bdb: error adding to rope: %w", err)) { + return + } + continue Entry + } + n = h.NextPageNo } - if err := r.add(data); err != nil { - return nil, fmt.Errorf("bdb: error adding to rope: %w", err) + // Double-check we'll read the intended amount. + if got, want := r.Size(), int64(offpg.Length); got != want { + zlog.Info(ctx). + Int64("got", got). + Int64("want", want). + Msg("bdb: expected data length botch") + } + + if !yield(&r, nil) { + return } - n = h.NextPageNo - } - // Double-check we'll read the intended amount. - if got, want := r.Size(), int64(offpg.Length); got != want { - zlog.Info(ctx). - Int64("got", got). - Int64("want", want). - Msg("bdb: expected data length botch") } - ret = append(ret, &r) } } - return ret, nil -} - -// Validate is currently here to fulfill an interface. -func (db *PackageDB) Validate(_ context.Context) error { - return nil } // Rope provides an [io.ReaderAt] over an ordered slice of [io.ReaderAt]. @@ -284,9 +305,11 @@ func (r *rope) ReadAt(b []byte, off int64) (int, error) { idx++ if idx != len(r.rd) { rdoff = 0 // Reading from the start, now that we're on the next one. - continue + break // May return EOF or nil on an exact-sized read, so hit the post-switch check. } fallthrough + // Don't need to handle non-EOF short reads because [io.ReaderAt] is documented + // to error on short reads. default: return n, err } diff --git a/rpm/bdb/bdb_test.go b/internal/rpm/bdb/bdb_test.go similarity index 78% rename from rpm/bdb/bdb_test.go rename to internal/rpm/bdb/bdb_test.go index 301243858..a45d06e50 100644 --- a/rpm/bdb/bdb_test.go +++ b/internal/rpm/bdb/bdb_test.go @@ -9,7 +9,7 @@ import ( "github.com/quay/zlog" - "github.com/quay/claircore/rpm/internal/rpm" + "github.com/quay/claircore/internal/rpm/rpmdb" ) func TestLoadPackage(t *testing.T) { @@ -32,19 +32,20 @@ func TestLoadPackage(t *testing.T) { if err := pkg.Parse(pkgf); err != nil { t.Fatal(err) } - rds, err := pkg.AllHeaders(ctx) - if err != nil { - t.Fatal(err) - } - t.Logf("got %d headers", len(rds)) - for _, rd := range rds { - var h rpm.Header + ct := 0 + for rd, err := range pkg.Headers(ctx) { + if err != nil { + t.Error(err) + continue + } + var h rpmdb.Header if err := h.Parse(ctx, rd); err != nil { t.Fatal(err) } + ct++ var found bool for i := range h.Infos { - if h.Infos[i].Tag == rpm.TagName { + if h.Infos[i].Tag == rpmdb.TagName { v, err := h.ReadData(ctx, &h.Infos[i]) if err != nil { t.Error(err) @@ -59,6 +60,7 @@ func TestLoadPackage(t *testing.T) { t.Error(`missing "name" tag`) } } + t.Logf("got %d headers", ct) }) } } diff --git a/rpm/bdb/doc.go b/internal/rpm/bdb/doc.go similarity index 100% rename from rpm/bdb/doc.go rename to internal/rpm/bdb/doc.go diff --git a/rpm/bdb/testdata/bad_hoffpage_len.Packages b/internal/rpm/bdb/testdata/bad_hoffpage_len.Packages similarity index 100% rename from rpm/bdb/testdata/bad_hoffpage_len.Packages rename to internal/rpm/bdb/testdata/bad_hoffpage_len.Packages diff --git a/rpm/bdb/testdata/ubi8.Packages b/internal/rpm/bdb/testdata/ubi8.Packages similarity index 100% rename from rpm/bdb/testdata/ubi8.Packages rename to internal/rpm/bdb/testdata/ubi8.Packages diff --git a/internal/rpm/database.go b/internal/rpm/database.go new file mode 100644 index 000000000..c8e8bb4a0 --- /dev/null +++ b/internal/rpm/database.go @@ -0,0 +1,228 @@ +package rpm + +import ( + "context" + "fmt" + "io" + "iter" + "runtime/trace" + "strings" + "sync" + + "github.com/quay/zlog" + + "github.com/quay/claircore" + "github.com/quay/claircore/internal/rpm/rpmdb" + "github.com/quay/claircore/internal/rpmver" +) + +// Database is a handle to an RPM database. +type Database struct { + pkgdb string + cleanup io.Closer + headers HeaderReader +} + +// Packages creates an iterator over the packages in the RPM database, +// translated to [claircore.Package]s. +// +// Continuing the sequence after an error is reported skips the current package +// and processes the next one. +// +// The returned iterator is single-use. +func (db *Database) Packages(ctx context.Context) iter.Seq2[claircore.Package, error] { + ctx, task := trace.NewTask(ctx, "internal/rpm.Database.PackagesIter") + + seq := func(yield func(claircore.Package, error) bool) { + defer task.End() + + srcs := map[string]*claircore.Package{ + "(none)": nil, + "": nil, + } + headers := db.headers.Headers(ctx) + seq := loadPackageInfo(ctx, headers) + var ok bool + ct := 0 + defer func() { + zlog.Debug(ctx). + Int("packages", ct). + Msg("processed rpm db") + }() + retErr := func(err error) (cont bool) { + trace.WithRegion(ctx, "internal/rpm.Database.PackagesYield", func() { cont = yield(claircore.Package{}, err) }) + return cont + } + retPkg := func(pkg claircore.Package) (cont bool) { + trace.WithRegion(ctx, "internal/rpm.Database.PackagesYield", func() { cont = yield(pkg, nil) }) + return cont + } + + for info, err := range seq { + if err != nil { + if !retErr(err) { + return + } + continue + } + + pkg := claircore.Package{ + Kind: claircore.BINARY, + Name: info.Name, + Arch: info.Arch, + Module: info.ModuleStream(), + RepositoryHint: info.Hint(), + PackageDB: db.pkgdb, + } + v := info.NEVRA() + pkg.Version = v.EVR() + printSourceVersionWarning(ctx) + + srcRPM := info.SourceRPM + // Remove `.(no)src.rpm` + srcRPM = strings.TrimSuffix(srcRPM, ".rpm") + srcRPM = strings.TrimSuffix(srcRPM, ".src") + srcRPM = strings.TrimSuffix(srcRPM, ".nosrc") + pkg.Source, ok = srcs[srcRPM] + for !ok { + v, err := rpmver.Parse(srcRPM) + if err != nil { + zlog.Info(ctx). + Err(err). + Msg("unable to parse SOURCERPM tag, skipping") + break + } + if v.Name == nil { + zlog.Info(ctx). + Msg("no name parse out of SOURCERPM tag, skipping") + break + } + src := claircore.Package{ + Kind: claircore.SOURCE, + Name: *v.Name, + Version: v.EVR(), + // Don't want [Info.Hint] here, as it would encode the + // binary package's checksum in a (synthesized) source + // package's information. + PackageDB: db.pkgdb, + } + + pkg.Source = &src + srcs[srcRPM] = &src + ok = true + } + + ct++ + if !retPkg(pkg) { + return + } + } + } + + return seq +} + +// SourceVersionWarning is a [sync.Once] for controlling the "invalid source +// version" warning log. +// +// BUG(hank) Can't reliably populate the source: there's no NEVR information, +// just a filename that (by convention) is the NVRA. There's an in-flight [PR] +// to rpm to add this information. This package should be updated when that's +// merged. +// +// [PR]: https://github.com/rpm-software-management/rpm/pull/3755 +var sourceVersionWarning sync.Once + +func printSourceVersionWarning(ctx context.Context) { + sourceVersionWarning.Do(func() { + zlog.Warn(ctx). + Strs("see-also", []string{ + `https://github.com/rpm-software-management/rpm/issues/2796`, + `https://github.com/rpm-software-management/rpm/discussions/3703`, + `https://github.com/rpm-software-management/rpm/pull/3755`, + }). + Msg("rpm source packages always record 0 epoch; this may cause incorrect matching") + }) +} + +// PopulatePathSet adds relevant paths from the RPM database to the provided +// [PathSet]. +func (db *Database) populatePathSet(ctx context.Context, s *PathSet) error { + ctx, task := trace.NewTask(ctx, "internal/rpm.Database.populatePathSet") + defer task.End() + + seq := loadPackageInfo(ctx, db.headers.Headers(ctx)) + ct := 0 + defer func() { + zlog.Debug(ctx). + Int("packages", ct). + Int("files", s.len()). + Msg("processed rpm db") + }() + + for info, err := range seq { + if err != nil { + return err + } + ct++ + info.InsertIntoSet(s) + } + return nil +} + +func (db *Database) Close() error { + if db.cleanup != nil { + return db.cleanup.Close() + } + return nil +} + +func (db *Database) String() string { + return db.pkgdb +} + +// LoadPackageInfo maps a sequence yielding package header bytes to a sequence +// yielding package [Info] values. +// +// Any errors from the underlying sequence are passed through, and any errors +// encountered are reported. Continuing after an error is reported starts +// processing the next package header. +func loadPackageInfo(ctx context.Context, headers iter.Seq2[io.ReaderAt, error]) iter.Seq2[Info, error] { + return func(yield func(Info, error) bool) { + var h rpmdb.Header + + for r, err := range headers { + if err != nil { + if !yield(Info{}, fmt.Errorf("internal/rpm: unable to read header: %w", err)) { + return + } + continue + } + + h = rpmdb.Header{} + if err := h.Parse(ctx, r); err != nil { + if !yield(Info{}, fmt.Errorf("internal/rpm: unable to parse header: %w", err)) { + return + } + continue + } + + var i Info + if err := i.Load(ctx, &h); err != nil { + if !yield(Info{}, fmt.Errorf("internal/rpm: unable to load package information: %w", err)) { + return + } + continue + } + + // This is *not* an rpm package, it's just a public key stored in the rpm database. + if i.Name == "gpg-pubkey" { + continue + } + + if !yield(i, nil) { + return + } + } + } +} diff --git a/internal/rpm/dbkind.go b/internal/rpm/dbkind.go new file mode 100644 index 000000000..6d781b1b3 --- /dev/null +++ b/internal/rpm/dbkind.go @@ -0,0 +1,14 @@ +package rpm + +type dbKind uint + +//go:generate -command stringer go run golang.org/x/tools/cmd/stringer +//go:generate stringer -linecomment -type dbKind + +const ( + _ dbKind = iota + + kindBDB // bdb + kindSQLite // sqlite + kindNDB // ndb +) diff --git a/rpm/dbkind_string.go b/internal/rpm/dbkind_string.go similarity index 100% rename from rpm/dbkind_string.go rename to internal/rpm/dbkind_string.go diff --git a/internal/rpm/files.go b/internal/rpm/files.go new file mode 100644 index 000000000..b5998122f --- /dev/null +++ b/internal/rpm/files.go @@ -0,0 +1,163 @@ +package rpm + +import ( + "context" + "errors" + "fmt" + "runtime" + "strings" + "sync" + "unique" + "weak" + + "github.com/quay/zlog" + "golang.org/x/sync/singleflight" + + "github.com/quay/claircore" +) + +// PkgCache is a process-wide cache for [PathSet]s. +// +// This allows for all callers to use a single [PathSet] for a given layer. +var pkgCache fileCache + +// FileCache implements a cache of [PathSet] values keyed by the layer digest. +type fileCache struct { + // map[unique.Handle[string]][weak.Pointer[PathSet]] + m sync.Map + sf singleflight.Group +} + +func (c *fileCache) cleanupFunc(wp weak.Pointer[PathSet]) func(unique.Handle[string]) { + return func(key unique.Handle[string]) { + c.m.CompareAndDelete(key, wp) + } +} + +// GetPathSet returns a [PathSet] for the provided layer, using a cached +// version if possible. +func (c *fileCache) GetPathSet(ctx context.Context, layer *claircore.Layer) (*PathSet, error) { + // This makes use of [weak.Pointer], which may be odd at first. + // + // The weak package has full documentation, but roughly: because a + // [weak.Pointer] does not keep a value alive for GC purposes, every use + // that retrieves the original pointer needs to assume that it may have + // become nil and handle that case before dereferencing it. + + key := unique.Make(layer.Hash.String()) + for { + v, ok := c.m.Load(key) + if !ok { + fn := func() (any, error) { + if v, ok := c.m.Load(key); ok { + if s := v.(weak.Pointer[PathSet]).Value(); s != nil { + return s, nil + } + c.m.CompareAndDelete(key, v) + } + + set := &PathSet{ + paths: make(map[string]struct{}), + } + sys, err := layer.FS() + if err != nil { + return nil, fmt.Errorf("internal/rpm: unable to open layer: %w", err) + } + seq, errFunc := FindDBs(ctx, sys) + defer func() { + err = errors.Join(err, errFunc()) + }() + + for found := range seq { + zlog.Debug(ctx). + Stringer("db", found). + Msg("found possible database") + err = func() error { + db, err := OpenDB(ctx, sys, found) + if err != nil { + return err + } + defer db.Close() + ctx := zlog.ContextWithValues(ctx, "db", db.String()) + zlog.Debug(ctx).Msg("examining database") + return db.populatePathSet(ctx, set) + }() + if err != nil { + return nil, err + } + + } + wp := weak.Make(set) + runtime.AddCleanup(set, c.cleanupFunc(wp), key) + c.m.Store(key, wp) + return set, nil + } + + ch := c.sf.DoChan(key.Value(), fn) + select { + case <-ctx.Done(): + return nil, context.Cause(ctx) + case res := <-ch: + if err := res.Err; err != nil { + return nil, err + } + return res.Val.(*PathSet), nil + } + } + + if s := v.(weak.Pointer[PathSet]).Value(); s != nil { + return s, nil + } + // Unable to upgrade: it's been garbage collected. + // Attempt to delete it so the next caller just has the load fail, + // then treat the key as novel. + c.m.CompareAndDelete(key, v) + } +} + +// NewPathSet returns a [PathSet] for the provided layer. +func NewPathSet(ctx context.Context, layer *claircore.Layer) (*PathSet, error) { + return pkgCache.GetPathSet(ctx, layer) +} + +// PathSet is used to check if a path is an RPM-owned file. +type PathSet struct { + // Disallow copy to prevent another reference to the "paths" map's + // backing memory. + _noCopy noCopy + paths map[string]struct{} +} + +// Contains reports true if the given path exists in the set of paths that are +// considered to be RPM files in the layer this [PathSet] was created for. +func (s *PathSet) Contains(p string) bool { + _, exists := s.paths[p] + return exists +} + +// GoString implements [fmt.GoStringer]. +func (s *PathSet) GoString() string { + var b strings.Builder + + b.WriteByte('[') + for k := range s.paths { + if b.Len() > 1 { + b.WriteByte(' ') + } + fmt.Fprintf(&b, `%q`, k) + } + b.WriteByte(']') + + return b.String() +} + +// Len reports the size of the set. +func (s *PathSet) len() int { + return len(s.paths) +} + +// NoCopy is a zero-sized type to trip the "copylocks" vet check. +type noCopy struct{} + +func (*noCopy) Lock() {} +func (*noCopy) Unlock() {} diff --git a/internal/rpm/files_test.go b/internal/rpm/files_test.go new file mode 100644 index 000000000..a0939314c --- /dev/null +++ b/internal/rpm/files_test.go @@ -0,0 +1,128 @@ +package rpm + +import ( + "context" + "runtime" + "testing" + "unique" + "weak" + + "github.com/quay/zlog" + + "github.com/quay/claircore" + "github.com/quay/claircore/test" +) + +type FileCheckerFileTestcase struct { + Name string + Owned bool + Path string +} + +type FileCheckerTestcase struct { + Name string + Layer test.LayerRef + Testcases []FileCheckerFileTestcase +} + +func (tc *FileCheckerTestcase) Run(ctx context.Context, t *testing.T, a *test.CachedArena) { + t.Run(tc.Name, func(t *testing.T) { + ctx := zlog.Test(ctx, t) + a.LoadLayerFromRegistry(ctx, t, tc.Layer) + r := a.Realizer(ctx).(*test.CachedRealizer) + t.Cleanup(func() { + if err := r.Close(); err != nil { + t.Error(err) + } + }) + + rl, err := r.RealizeDescriptions(ctx, []claircore.LayerDescription{ + { + Digest: tc.Layer.Digest, + URI: "http://example.com", + MediaType: test.MediaType, + Headers: make(map[string][]string), + }, + }) + if err != nil { + t.Fatal(err) + } + set, err := NewPathSet(ctx, &rl[0]) + if err != nil { + t.Fatal(err) + } + defer runtime.KeepAlive(set) + + for _, tc := range tc.Testcases { + t.Run(tc.Name, func(t *testing.T) { + t.Parallel() + ctx := zlog.Test(ctx, t) + ctx, cancel := context.WithCancel(ctx) + defer cancel() + + set, err := NewPathSet(ctx, &rl[0]) + if err != nil { + t.Fatal(err) + } + t.Logf("checking path: %s", tc.Path) + if got, want := set.Contains(tc.Path), tc.Owned; got != want { + t.Errorf("got: %v, want: %v", got, want) + } + }) + } + }) +} + +func TestIsRPMFile(t *testing.T) { + ctx := zlog.Test(context.Background(), t) + a := test.NewCachedArena(t) + + t.Cleanup(func() { + t.Log("running GC") + runtime.GC() + ct := 0 + pkgCache.m.Range(func(k, v any) bool { + key := k.(unique.Handle[string]) + t.Logf("%s\tcache entry not removed", key.Value()) + f := v.(weak.Pointer[PathSet]) + if f.Value() != nil { + t.Errorf("%s\table to upgrade weak pointer", key.Value()) + } + ct++ + return true + }) + t.Logf("%d cache entries remaining", ct) + }) + + tcs := []FileCheckerTestcase{ + { + Name: "nodejs18", + Layer: test.LayerRef{ + Registry: "registry.access.redhat.com", + Name: "ubi9/nodejs-18", + Digest: `sha256:1ae06b64755052cef4c32979aded82a18f664c66fa7b50a6d2924afac2849c6e`, + }, + Testcases: []FileCheckerFileTestcase{ + { + Name: "FoundNode", + Owned: true, + Path: "usr/lib/node_modules/npm/node_modules/safe-buffer/package.json", + }, + { + Name: "FoundPython", + Owned: true, + Path: "usr/lib64/python3.9/site-packages/libcomps-0.1.18-py3.9.egg-info/PKG-INFO", + }, + { + Name: "NotFound", + Owned: false, + Path: "usr/lib/node_modules/npm/node_modules/safe-buffer/package.jsonx", + }, + }, + }, + } + + for _, tc := range tcs { + tc.Run(ctx, t, a) + } +} diff --git a/internal/rpm/find.go b/internal/rpm/find.go new file mode 100644 index 000000000..b4b6dd1dc --- /dev/null +++ b/internal/rpm/find.go @@ -0,0 +1,271 @@ +package rpm + +import ( + "context" + "errors" + "fmt" + "io" + "io/fs" + "iter" + "os" + "path" + "unique" + + "github.com/quay/zlog" + "golang.org/x/sync/errgroup" + + "github.com/quay/claircore/internal/rpm/bdb" + "github.com/quay/claircore/internal/rpm/ndb" + "github.com/quay/claircore/internal/rpm/sqlite" +) + +// FindDBs walks the passed [fs.FS] looking for any files that seem to be rpm +// databases. +// +// The returned iterator closes over the passed [fs.FS]. The returned [FoundDB] +// values are only valid to use with the same [fs.FS] value. +func FindDBs(ctx context.Context, sys fs.FS) (iter.Seq[FoundDB], func() error) { + iterationDone := errors.New("iteration done") + ctx, done := context.WithCancelCause(ctx) + // Errgroup not really necessary -- this could be done with a shared + // variable and a channel -- but the API is nice. + eg, ctx := errgroup.WithContext(ctx) + + ch := make(chan FoundDB) + eg.Go(func() error { + defer close(ch) + return fs.WalkDir(sys, ".", walk(ctx, ch, sys)) + }) + seq := func(yield func(FoundDB) bool) { + defer done(iterationDone) + for { + select { + case f, ok := <-ch: + if !ok { + return + } + if !yield(f) { + return + } + case <-ctx.Done(): + return + } + } + } + errFunc := func() error { + done(iterationDone) + err := eg.Wait() + // If the iterator exhausted normally or this function was called early, + // ignore the cancellation. + if errors.Is(err, context.Canceled) && + errors.Is(context.Cause(ctx), iterationDone) { + err = nil + } + return err + } + + return seq, errFunc +} + +func walk(ctx context.Context, out chan<- FoundDB, sys fs.FS) fs.WalkDirFunc { + handle := unique.Make(sys) + return func(p string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() { + return nil + } + + dir, n := path.Split(p) + dir = path.Clean(dir) + var kind dbKind + switch n { + case `Packages`: + f, err := sys.Open(p) + if err != nil { + return err + } + ok := bdb.CheckMagic(ctx, f) + f.Close() + if !ok { + return nil + } + kind = kindBDB + case `rpmdb.sqlite`: + kind = kindSQLite + case `Packages.db`: + f, err := sys.Open(p) + if err != nil { + return err + } + ok := ndb.CheckMagic(ctx, f) + f.Close() + if !ok { + return nil + } + kind = kindNDB + } + if kind == 0 { + return nil + } + + select { + case out <- FoundDB{ + path: dir, + kind: kind, + handle: handle, + }: + // OK + case <-ctx.Done(): + return fs.SkipAll + } + return nil + } +} + +// FoundDB is a pointer to a probable rpm database found in an [fs.FS]. +type FoundDB struct { + path string + kind dbKind + handle unique.Handle[fs.FS] +} + +// String implements [fmt.Stringer]. +func (f FoundDB) String() string { + return f.kind.String() + ":" + f.path +} + +// Filename constructs the path to the main database file. +func (f FoundDB) filename() string { + var n string + switch f.kind { + case kindBDB: + n = `Packages` + case kindSQLite: + n = `rpmdb.sqlite` + case kindNDB: + n = `Packages.db` + default: + panic("programmer error: bad kind: " + f.kind.String()) + } + return path.Join(f.path, n) +} + +// OpenDB attempts to open the database pointed to by "found." +func OpenDB(ctx context.Context, sys fs.FS, found FoundDB) (*Database, error) { + // Previous incarnations of this package ended up duplicating large chunks + // of logic around opening the databases. This pass attempts to fix that by + // using new go features. + + switch { + case found.kind == 0: + return nil, errors.New("internal/rpm: programmer error: passed zero FoundDB") + case unique.Make(sys) != found.handle: + return nil, errors.New("internal/rpm: programmer error: passed mismatched fs.FS and FoundDB") + } + + f, err := sys.Open(found.filename()) + if err != nil { + return nil, fmt.Errorf("internal/rpm: unable to open %s db: %w", found.kind.String(), err) + } + defer func() { + if err := f.Close(); err != nil { + zlog.Warn(ctx).Stringer("kind", found.kind).Err(err).Msg("unable to close db") + } + }() + + cleanup := &databaseCleanup{} + db := Database{ + pkgdb: found.path, + cleanup: cleanup, + } + + spool, err := os.CreateTemp(os.TempDir(), fmt.Sprintf(`rpm.package.%v.`, found.kind)) + if err != nil { + return nil, fmt.Errorf("internal/rpm: error spooling db: %w", err) + } + ctx = zlog.ContextWithValues(ctx, "file", spool.Name()) + cleanup.spool = spool + zlog.Debug(ctx). + Msg("copying db out of fs.FS") + + // Need to have the file linked into the filesystem for the sqlite package. + // + // See [this post] for an idea on working around it: + // + // int sqlite_fdopen( + // int fd, + // sqlite3 **connection) + // { + // char uri[48]; + // + // snprintf(uri, sizeof uri, "file:///dev/fd/%d?immutable=1", fd); + // return sqlite3_open_v2( + // uri, + // connection, + // SQLITE_OPEN_READONLY | SQLITE_OPEN_URI, + // NULL); + // } + // + // [this post]: https://sqlite.org/forum/info/57aaaf20cf703d301fed5aeaef59e70723f1d9454fb3a4e6383b2bfac6897e5a + if _, err := io.Copy(spool, f); err != nil { + if err := spool.Close(); err != nil { + zlog.Warn(ctx).Err(err).Msg("unable to close spool") + } + return nil, fmt.Errorf("internal/rpm: error spooling db: %w", err) + } + if err := spool.Sync(); err != nil { + zlog.Warn(ctx).Err(err).Msg("unable to sync spool; results may be Weird") + } + + switch found.kind { + case kindSQLite: + sdb, err := sqlite.Open(spool.Name()) + if err != nil { + return nil, fmt.Errorf("internal/rpm: unable to open sqlite db: %w", err) + } + db.headers = sdb + cleanup.close = sdb.Close + case kindBDB: + var bpdb bdb.PackageDB + if err := bpdb.Parse(spool); err != nil { + return nil, fmt.Errorf("internal/rpm: error parsing bdb db: %w", err) + } + db.headers = &bpdb + case kindNDB: + var npdb ndb.PackageDB + if err := npdb.Parse(spool); err != nil { + return nil, fmt.Errorf("internal/rpm: error parsing ndb db: %w", err) + } + db.headers = &npdb + default: + panic("unreachable") + } + zlog.Debug(ctx). + Stringer("db", found). + Msg("opened database") + + if v, ok := db.headers.(validator); ok { + if err := v.Validate(ctx); err != nil { + return nil, errors.Join(err, db.Close()) + } + } + + return &db, nil +} + +type databaseCleanup struct { + spool *os.File + close func() error +} + +func (c *databaseCleanup) Close() (err error) { + if c.spool != nil { + err = errors.Join(err, c.spool.Close(), os.Remove(c.spool.Name())) + } + if c.close != nil { + err = errors.Join(err, c.close()) + } + return err +} diff --git a/internal/rpm/info.go b/internal/rpm/info.go new file mode 100644 index 000000000..c05414df7 --- /dev/null +++ b/internal/rpm/info.go @@ -0,0 +1,255 @@ +package rpm + +import ( + "bytes" + "context" + "fmt" + "iter" + "net/url" + "path" + "regexp" + "slices" + "strconv" + "strings" + "sync" + + "golang.org/x/crypto/openpgp/packet" + + "github.com/quay/claircore/internal/rpm/rpmdb" + "github.com/quay/claircore/internal/rpmver" +) + +// Info is the package information extracted from the RPM header. +type Info struct { + Name string + Version string + Release string + SourceRPM string + Module string + Arch string + Digest string + Signature []byte // This is a PGP signature packet. + dirname []string + dirindex []int32 + basename []string + DigestAlgo int + Epoch int +} + +// Load populates the receiver with information extracted from the provided +// [rpmdb.Header]. +func (i *Info) Load(ctx context.Context, h *rpmdb.Header) error { + for idx := range h.Infos { + e := &h.Infos[idx] + if _, ok := wantTags[e.Tag]; !ok { + continue + } + v, err := h.ReadData(ctx, e) + if err != nil { + return err + } + switch e.Tag { + case rpmdb.TagName: + i.Name = v.(string) + case rpmdb.TagEpoch: + i.Epoch = int(v.([]int32)[0]) + case rpmdb.TagVersion: + i.Version = v.(string) + case rpmdb.TagRelease: + i.Release = v.(string) + case rpmdb.TagSourceRPM: + i.SourceRPM = v.(string) + case rpmdb.TagModularityLabel: + i.Module = v.(string) + case rpmdb.TagArch: + i.Arch = v.(string) + case rpmdb.TagPayloadDigestAlgo: + i.DigestAlgo = int(v.([]int32)[0]) + case rpmdb.TagPayloadDigest: + i.Digest = v.([]string)[0] + case rpmdb.TagSigPGP: + i.Signature = v.([]byte) + case rpmdb.TagDirnames: // v5-only + i.dirname = v.([]string) + case rpmdb.TagDirindexes: // v5-only + i.dirindex = v.([]int32) + case rpmdb.TagBasenames: // v5-only + i.basename = v.([]string) + case rpmdb.TagFilenames: + // Filenames is the tag used in rpm4 -- this is a best-effort for + // supporting it. This should be exclusive with the + // Dirnames/Dirindexes/Basenames tags. + // + // This takes the whole filenames value and splits it into an + // rpm5-style dir+base. + names := v.([]string) + slices.Sort(names) + i.dirname = make([]string, 0) + i.dirindex = make([]int32, 0, len(names)) + i.basename = make([]string, 0, len(names)) + cur := -1 + for _, name := range names { + dir, base := path.Split(name) + i.basename = append(i.basename, base) + if len(i.dirname) == 0 || i.dirname[cur] != dir { + cur = len(i.dirname) + i.dirname = append(i.dirname, dir) + } + i.dirindex = append(i.dirindex, int32(cur)) + } + default: + panic(fmt.Sprintf("programmer error: unhandled tag: %v", e.Tag)) + } + } + + if b, d := len(i.basename), len(i.dirindex); b != d { + return fmt.Errorf(`internal/rpm: Info: mismatched "base" and "dir" counts: %d, %d`, b, d) + } + if len(i.dirindex) != 0 { + if v, bound := slices.Max(i.dirindex), len(i.dirname); int(v) >= bound { + return fmt.Errorf(`internal/rpm: Info: invalid "dirindex": index %d is out-of-bounds (length %d)`, v, bound) + } + } + + return nil +} + +// Path reconstructs the j-th path. +// +// We only want '/'-separated paths, even if running on some other, weird OS. It +// seems that RPM assumes '/' throughout. +// +// The paths coming out of rpm are absolute, so this function makes them +// [fs.FS]-valid paths. +func (i *Info) path(j int) string { + return path.Join(i.dirname[i.dirindex[j]][1:], i.basename[j]) +} + +// Filenames returns an iterator over all paths in the [Info]. +// +// The returned paths are [fs.FS]-valid. +func (i *Info) Filenames() iter.Seq[string] { + return func(yield func(string) bool) { + for j := range i.basename { + if !yield(i.path(j)) { + return + } + } + } +} + +// InsertIntoSet inserts filtered "relevant" paths into the provided [PathSet]. +func (i *Info) InsertIntoSet(s *PathSet) { + pat := filePatterns() + for p := range i.Filenames() { + if pat.MatchString(p) { + s.paths[p] = struct{}{} + } + } +} + +// NEVRA constructs a Name-Epoch-Version-Release-Architecture [rpmver.Version]. +func (i *Info) NEVRA() rpmver.Version { + return rpmver.Version{ + Name: &i.Name, + Architecture: &i.Arch, + Epoch: strconv.Itoa(i.Epoch), + Version: i.Version, + Release: i.Release, + } +} + +// Hint constructs a string suitable to be used as the "RepositoryHint". +func (i *Info) Hint() string { + v := url.Values{} + if i.Digest != "" { + switch i.DigestAlgo { + case 8: + v.Set("hash", "sha256:"+i.Digest) + } + } + if len(i.Signature) != 0 { + prd := packet.NewReader(bytes.NewReader(i.Signature)) + p, err := prd.Next() + for ; err == nil; p, err = prd.Next() { + switch p := p.(type) { + case *packet.SignatureV3: + if p.SigType != 0 { + continue + } + v.Set("key", fmt.Sprintf("%016x", p.IssuerKeyId)) + case *packet.Signature: + if p.SigType != 0 || p.IssuerKeyId == nil { + continue + } + v.Set("key", fmt.Sprintf("%016x", *p.IssuerKeyId)) + } + } + } + return v.Encode() +} + +// ModuleStream reports the module and stream from the full module version. +// +// It returns the empty string if the [Info] does not describe a package from a +// module. +func (i *Info) ModuleStream() string { + if strings.Count(i.Module, ":") <= 1 { + return "" + } + first := true + idx := strings.IndexFunc(i.Module, func(r rune) bool { + if r != ':' { + return false + } + if first { + first = false + return false + } + return true + }) + return i.Module[:idx] +} + +// TODO(hank) This regexp-based strategy is not very robust. +// Long-term, we should add pattern matching akin to [yara] or file(1) as a +// plugin mechanism that all indexers can use. That way, the Go indexer +// could register a pattern and use a shared filter over the +// [fs.WalkDirFunc] while this package (and dpkg, etc) can tell that another +// indexer will find those files relevant. +// +// [yara]: https://github.com/VirusTotal/yara +var ( + // FilePatterns is a regular expression for *any* file that may need to be + // recorded alongside a package. + // + // The tested strings are absolute paths. + filePatterns = sync.OnceValue(func() *regexp.Regexp { + pat := []string{ + `^.*/[^/]+\.[ejw]ar$`, // Jar files + `^.*/site-packages/[^/]+\.egg-info/PKG-INFO$`, // Python packages + `^.*/package.json$`, // npm packages + `^.*/[^/]+\.gemspec$`, // ruby gems + `^/usr/s?bin/[^/]+$`, // any executable + `^/usr/libexec/[^/]+/[^/]+$`, // sometimes the executables are here too + } + return regexp.MustCompile(strings.Join(pat, `|`)) + }) +) + +var wantTags = map[rpmdb.Tag]struct{}{ + rpmdb.TagArch: {}, + rpmdb.TagBasenames: {}, + rpmdb.TagDirindexes: {}, + rpmdb.TagDirnames: {}, + rpmdb.TagEpoch: {}, + rpmdb.TagFilenames: {}, + rpmdb.TagModularityLabel: {}, + rpmdb.TagName: {}, + rpmdb.TagPayloadDigest: {}, + rpmdb.TagPayloadDigestAlgo: {}, + rpmdb.TagRelease: {}, + rpmdb.TagSigPGP: {}, + rpmdb.TagSourceRPM: {}, + rpmdb.TagVersion: {}, +} diff --git a/rpm/ndb/doc.go b/internal/rpm/ndb/doc.go similarity index 100% rename from rpm/ndb/doc.go rename to internal/rpm/ndb/doc.go diff --git a/rpm/ndb/murmur.go b/internal/rpm/ndb/murmur.go similarity index 100% rename from rpm/ndb/murmur.go rename to internal/rpm/ndb/murmur.go diff --git a/rpm/ndb/murmur_test.go b/internal/rpm/ndb/murmur_test.go similarity index 100% rename from rpm/ndb/murmur_test.go rename to internal/rpm/ndb/murmur_test.go diff --git a/internal/rpm/ndb/ndb.go b/internal/rpm/ndb/ndb.go new file mode 100644 index 000000000..42e865236 --- /dev/null +++ b/internal/rpm/ndb/ndb.go @@ -0,0 +1,30 @@ +package ndb + +import ( + "context" + "encoding/binary" + "io" +) + +var le = binary.LittleEndian + +// Used throughout the various DBs. +const ( + slotSize = 4 * 4 + slotStart = 2 +) + +// CheckMagic reports whether the Reader starts with a magic header for +// a file format supported by this package. +func CheckMagic(_ context.Context, r io.Reader) bool { + const ( + xdb = 'R' | 'p'<<8 | 'm'<<16 | 'X'<<24 + pkg = 'R' | 'p'<<8 | 'm'<<16 | 'P'<<24 + ) + b := make([]byte, 4) + if _, err := io.ReadFull(r, b); err != nil { + return false + } + m := le.Uint32(b) + return m == xdb || m == pkg +} diff --git a/rpm/ndb/package.go b/internal/rpm/ndb/package.go similarity index 94% rename from rpm/ndb/package.go rename to internal/rpm/ndb/package.go index 799de7e2d..860fff347 100644 --- a/rpm/ndb/package.go +++ b/internal/rpm/ndb/package.go @@ -6,6 +6,7 @@ import ( "fmt" "hash/adler32" "io" + "iter" ) // Pages are hard-coded to 4096 bytes for the Package database; this @@ -67,22 +68,16 @@ func (db *PackageDB) Parse(r io.ReaderAt) error { return nil } -// AllHeaders returns ReaderAts for all RPM headers in the PackageDB. -func (db *PackageDB) AllHeaders(_ context.Context) ([]io.ReaderAt, error) { - r := make([]io.ReaderAt, len(db.slot)) - var err error - for i, s := range db.slot { - r[i], err = db.GetHeader(s.Index) - if err != nil { - return nil, err +// Headers returns an iterator over all the header blobs in the database. +func (db *PackageDB) Headers(_ context.Context) iter.Seq2[io.ReaderAt, error] { + return func(yield func(io.ReaderAt, error) bool) { + for _, s := range db.slot { + r, err := db.GetHeader(s.Index) + if !yield(r, err) { + return + } } } - return r, nil -} - -// Validate is currently here to fulfill an interface. -func (db *PackageDB) Validate(_ context.Context) error { - return nil } // GetHeader returns an [io.ReaderAt] populated with [rpm.Header] data or diff --git a/rpm/ndb/package_test.go b/internal/rpm/ndb/package_test.go similarity index 80% rename from rpm/ndb/package_test.go rename to internal/rpm/ndb/package_test.go index fdf148c63..3014725bd 100644 --- a/rpm/ndb/package_test.go +++ b/internal/rpm/ndb/package_test.go @@ -9,7 +9,7 @@ import ( "github.com/quay/zlog" - "github.com/quay/claircore/rpm/internal/rpm" + "github.com/quay/claircore/internal/rpm/rpmdb" ) func TestLoadPackage(t *testing.T) { @@ -33,18 +33,18 @@ func TestLoadPackage(t *testing.T) { if err := pkg.Parse(pkgf); err != nil { t.Fatal("error parsing Packages file", err) } - rds, err := pkg.AllHeaders(ctx) - if err != nil { - t.Fatal("error getting AllHeaders", err) - } - for _, rd := range rds { - var h rpm.Header + for rd, err := range pkg.Headers(ctx) { + if err != nil { + t.Error(err) + continue + } + var h rpmdb.Header if err := h.Parse(ctx, rd); err != nil { t.Fatal(err) } var found bool for i := range h.Infos { - if h.Infos[i].Tag == rpm.TagName { + if h.Infos[i].Tag == rpmdb.TagName { v, err := h.ReadData(ctx, &h.Infos[i]) if err != nil { t.Error(err) diff --git a/rpm/ndb/testdata/Packages.db b/internal/rpm/ndb/testdata/Packages.db similarity index 100% rename from rpm/ndb/testdata/Packages.db rename to internal/rpm/ndb/testdata/Packages.db diff --git a/rpm/ndb/testdata/Packages_nonsense_block.db b/internal/rpm/ndb/testdata/Packages_nonsense_block.db similarity index 100% rename from rpm/ndb/testdata/Packages_nonsense_block.db rename to internal/rpm/ndb/testdata/Packages_nonsense_block.db diff --git a/rpm/ndb/testdata/Packages_unreadable.db b/internal/rpm/ndb/testdata/Packages_unreadable.db similarity index 100% rename from rpm/ndb/testdata/Packages_unreadable.db rename to internal/rpm/ndb/testdata/Packages_unreadable.db diff --git a/internal/rpm/rpm.go b/internal/rpm/rpm.go new file mode 100644 index 000000000..529b725b8 --- /dev/null +++ b/internal/rpm/rpm.go @@ -0,0 +1,22 @@ +// Package rpm allows for inspecting RPM databases in BerkleyDB, NDB, and SQLite +// formats. +package rpm + +import ( + "context" + "io" + "iter" +) + +const Version = "10" + +// HeaderReader is the interface implemented for in-process RPM database handlers. +type HeaderReader interface { + Headers(context.Context) iter.Seq2[io.ReaderAt, error] +} + +// Validator is the extra interface an RPM database can implement if it needs +// extra checks after opening. +type validator interface { + Validate(context.Context) error +} diff --git a/internal/rpm/rpmdb/doc.go b/internal/rpm/rpmdb/doc.go new file mode 100644 index 000000000..d621cf7fa --- /dev/null +++ b/internal/rpm/rpmdb/doc.go @@ -0,0 +1,9 @@ +// Package rpmdb contains some internal helpers for working with RPM +// databases. +// +// The actual data stored in various databases is independent of the disk +// format, once extracted. + +// See the reference material at +// https://rpm-software-management.github.io/rpm/manual/. +package rpmdb diff --git a/rpm/internal/rpm/header.go b/internal/rpm/rpmdb/header.go similarity index 92% rename from rpm/internal/rpm/header.go rename to internal/rpm/rpmdb/header.go index 4d4ffab67..659063fc1 100644 --- a/rpm/internal/rpm/header.go +++ b/internal/rpm/rpmdb/header.go @@ -1,4 +1,4 @@ -package rpm +package rpmdb import ( "bufio" @@ -11,9 +11,6 @@ import ( "unsafe" ) -// See the reference material at -// https://rpm-software-management.github.io/rpm/manual/. - // Header is a parsed RPM header. type Header struct { tags *io.SectionReader @@ -55,7 +52,7 @@ func ParseHeader(ctx context.Context, r io.ReaderAt) (*Header, error) { // The ReaderAt must stay available throughout the lifetime of the Header. func (h *Header) Parse(ctx context.Context, r io.ReaderAt) error { if err := h.loadArenas(ctx, r); err != nil { - return fmt.Errorf("rpm: failed to parse header: %w", err) + return fmt.Errorf("rpmdb: failed to parse header: %w", err) } var isBDB bool switch err := h.verifyRegion(ctx); { @@ -63,10 +60,10 @@ func (h *Header) Parse(ctx context.Context, r io.ReaderAt) error { case errors.Is(err, errNoRegion): isBDB = true default: - return fmt.Errorf("rpm: failed to parse header: %w", err) + return fmt.Errorf("rpmdb: failed to parse header: %w", err) } if err := h.verifyInfo(ctx, isBDB); err != nil { - return fmt.Errorf("rpm: failed to parse header: %w", err) + return fmt.Errorf("rpmdb: failed to parse header: %w", err) } return nil } @@ -87,7 +84,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) } b := make([]byte, e.count) if _, err := h.data.ReadAt(b, int64(e.offset)); err != nil { - return nil, fmt.Errorf("rpm: header: error reading binary: %w", err) + return nil, fmt.Errorf("rpmdb: header: error reading binary: %w", err) } return b, nil case TypeI18nString, TypeStringArray: @@ -98,7 +95,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) s[i] = sc.Text() } if err := sc.Err(); err != nil { - return nil, fmt.Errorf("rpm: header: error reading string array: %w", err) + return nil, fmt.Errorf("rpmdb: header: error reading string array: %w", err) } return s, nil case TypeString: @@ -106,7 +103,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) r := bufio.NewReader(io.NewSectionReader(h.data, int64(e.offset), -1)) s, err := r.ReadString(0x00) if err != nil { - return nil, fmt.Errorf("rpm: header: error reading string: %w", err) + return nil, fmt.Errorf("rpmdb: header: error reading string: %w", err) } // ReadString includes the delimiter, be sure to remove it. return s[:len(s)-1], nil @@ -118,7 +115,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) b := make([]byte, 8) for i := range r { if _, err := io.ReadFull(sr, b); err != nil { - return nil, fmt.Errorf("rpm: header: error reading %T: %w", r[0], err) + return nil, fmt.Errorf("rpmdb: header: error reading %T: %w", r[0], err) } r[i] = binary.BigEndian.Uint64(b) } @@ -128,7 +125,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) b := make([]byte, 4) for i := range r { if _, err := io.ReadFull(sr, b); err != nil { - return nil, fmt.Errorf("rpm: header: error reading %T: %w", r[0], err) + return nil, fmt.Errorf("rpmdb: header: error reading %T: %w", r[0], err) } r[i] = int32(binary.BigEndian.Uint32(b)) } @@ -138,7 +135,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) b := make([]byte, 2) for i := range r { if _, err := io.ReadFull(sr, b); err != nil { - return nil, fmt.Errorf("rpm: header: error reading %T: %w", r[0], err) + return nil, fmt.Errorf("rpmdb: header: error reading %T: %w", r[0], err) } r[i] = int16(binary.BigEndian.Uint16(b)) } @@ -146,7 +143,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) case TypeInt8: b := make([]byte, int(e.count)) if _, err := io.ReadFull(sr, b); err != nil { - return nil, fmt.Errorf("rpm: header: error reading int8: %w", err) + return nil, fmt.Errorf("rpmdb: header: error reading int8: %w", err) } // Despite byte == uint8 and uint8 being convertible to int8, this is // the only way I can figure out to avoid an extra copy or using a @@ -156,7 +153,7 @@ func (h *Header) ReadData(_ context.Context, e *EntryInfo) (interface{}, error) case TypeChar: // Char and Bin are different because they're offset differently. r := make([]byte, int(e.count)) if _, err := sr.ReadAt(r, 0); err != nil { - return nil, fmt.Errorf("rpm: header: error reading char: %w", err) + return nil, fmt.Errorf("rpmdb: header: error reading char: %w", err) } return r, nil } diff --git a/rpm/internal/rpm/header_test.go b/internal/rpm/rpmdb/header_test.go similarity index 97% rename from rpm/internal/rpm/header_test.go rename to internal/rpm/rpmdb/header_test.go index 4cc6af9f6..6f1331dd5 100644 --- a/rpm/internal/rpm/header_test.go +++ b/internal/rpm/rpmdb/header_test.go @@ -1,4 +1,4 @@ -package rpm +package rpmdb import ( "context" diff --git a/rpm/internal/rpm/rpm_tag.go b/internal/rpm/rpmdb/rpm_tag.go similarity index 95% rename from rpm/internal/rpm/rpm_tag.go rename to internal/rpm/rpmdb/rpm_tag.go index f8f358cf4..7d8f1f125 100644 --- a/rpm/internal/rpm/rpm_tag.go +++ b/internal/rpm/rpmdb/rpm_tag.go @@ -1,4 +1,4 @@ -package rpm +package rpmdb // C.f. rpm's include/rpm/rpmtag.h -- This was done by hand with some editor // scripts, but there has to be a better way. @@ -353,6 +353,27 @@ const ( TagModularityLabel TagPayloadDigestAlt TagArchSuffix + TagSpec + TagTranslationURL + TagUpstreamReleases + TagSourceLicense // internal + TagPreUntrans + TagPostUntrans + TagPreUntransProg + TagPostUntransProg + TagPreUntransFlags + TagPostUntransFlags + TagSysusers // extension + TagBuildSystem // internal + TagBuildOption // internal + TagPayloadSize + TagPayloadSizeAlt + TagRPMFormat + TagFileMimeIndex + TagMimeDict + TagFileMimes // extension + TagPackageDigests + TagPackageDigestAlgos ) // Stealing a trick from codegen to assert some values. @@ -363,7 +384,7 @@ func _() { _ = x[TagTriggerIndex-1069] _ = x[TagNVRA-1196] _ = x[TagTriggerScriptFlags-5027] - _ = x[TagPayloadDigestAlt-5097] + _ = x[TagPackageDigestAlgos-5119] } // Kind is the Kind of data stored in a given Tag. diff --git a/rpm/internal/rpm/tag_string.go b/internal/rpm/rpmdb/tag_string.go similarity index 93% rename from rpm/internal/rpm/tag_string.go rename to internal/rpm/rpmdb/tag_string.go index 135bbb1d1..0d17ecde5 100644 --- a/rpm/internal/rpm/tag_string.go +++ b/internal/rpm/rpmdb/tag_string.go @@ -1,6 +1,6 @@ // Code generated by "stringer -type Tag,Kind"; DO NOT EDIT. -package rpm +package rpmdb import "strconv" @@ -319,6 +319,27 @@ func _() { _ = x[TagModularityLabel-5096] _ = x[TagPayloadDigestAlt-5097] _ = x[TagArchSuffix-5098] + _ = x[TagSpec-5099] + _ = x[TagTranslationURL-5100] + _ = x[TagUpstreamReleases-5101] + _ = x[TagSourceLicense-5102] + _ = x[TagPreUntrans-5103] + _ = x[TagPostUntrans-5104] + _ = x[TagPreUntransProg-5105] + _ = x[TagPostUntransProg-5106] + _ = x[TagPreUntransFlags-5107] + _ = x[TagPostUntransFlags-5108] + _ = x[TagSysusers-5109] + _ = x[TagBuildSystem-5110] + _ = x[TagBuildOption-5111] + _ = x[TagPayloadSize-5112] + _ = x[TagPayloadSizeAlt-5113] + _ = x[TagRPMFormat-5114] + _ = x[TagFileMimeIndex-5115] + _ = x[TagMimeDict-5116] + _ = x[TagFileMimes-5117] + _ = x[TagPackageDigests-5118] + _ = x[TagPackageDigestAlgos-5119] } const ( @@ -331,7 +352,7 @@ const ( _Tag_name_6 = "TagNameTagVersionTagReleaseTagEpochTagSummaryTagDescriptionTagBuildTimeTagBuildHostTagInstallTimeTagSizeTagDistributionTagVendorTagGIFTagXPMTagLicenseTagPackagerTagGroupTagChangelogTagSourceTagPatchTagURLTagOSTagArchTagPreInstallTagPostInstallTagPreUninstallTagPostUninstallTagOldFilenamesTagFileSizesTagFileStatesTagFileModesTagFileUidsTagFileGidsTagFileRDevsTagFileMTimesTagFileDigestsTagFileLinkTosTagFileFlagsTagRootTagFileUsernameTagFileGroupnameTagExcludeTagExclusiveTagIconTagSourceRPMTagFileVerifyFlagsTagArchiveSizeTagProvideNameTagRequireFlagsTagRequireNameTagRequireVersionTagNoSourceTagNoPatchTagConflictFlagsTagConflictNameTagConflictVersionTagDefaultPrefixTagBuildRootTagInstallPrefixTagExcludeArchTagExcludeOSTagExclusiveArchTagExclusiveOSTagAutoReqProvTagRPMVersionTagTriggerScriptsTagTriggerNameTagTriggerVersionTagTriggerFlagsTagTriggerIndex" _Tag_name_7 = "TagVerifyScriptTagChangelogTimeTagChangelogNameTagChangelogTextTagBrokenMD5TagPreReqTagPreInstallProgTagPostInstallProgTagPreUninstallProgTagPostUninstallProgTagBuildArchsTagObsoleteNameTagVerifyScriptProgTagTriggerScriptProgTagDocDirTagCookieTagFileDevicesTagFileInodesTagFileLangsTagPrefixesTagInstallPrefixesTagTriggerInstallTagTriggerUninstallTagTriggerPostUninstallTagAutoReqTagAutoProvTagCapabilityTagSourcePackageTagOldOriginalFilenamesTagBuildPreReqTagBuildRequiresTagBuildConflictsTagBuildMacrosTagProvideFlagsTagProvideVersionTagObsoleteFlagsTagObsoleteVersionTagDirindexesTagBasenamesTagDirnamesTagOrigDirindexesTagOrigBasenamesTagOrigDirnamesTagOptFlagsTagDistURLTagPayloadFormatTagPayloadCompressorTagPayloadFlagsTagInstallColorTagInstallTIDTagRemoveTIDTagSHA1RHNTagRHNPlatformTagPlatformTagPatchesNameTagPatchesFlagsTagPatchesVersionTagCacheCtimeTagCachePkgPathTagCachePkgSizeTagCachePkgMtimeTagFileColorsTagFileClassTagClassDictTagFileDependsXTagFileDependsNTagDependsDictTagSourcePkgIDTagFileContextsTagFSContextsTagREContextsTagPoliciesTagPreTransTagPostTransTagPreTransProgTagPostTransProgTagDistTagTagOldSuggestsNameTagOldSuggestsVersionTagOldSuggestsFlagsTagOldEnhancesNameTagOldEnhancesVersionTagOldEnhancesFlagsTagPriorityTagCVSIDTagBLinkPkgIDTagBLinkHdrIDTagBLinkNEVRATagFLinkPkgIDTagFLinkHdrIDTagFLinkNEVRATagPackageOriginTagTriggerPreInstallTagBuildSuggestsTagBuildEnhancesTagScriptStatesTagScriptMetricsTagBuildCPUClockTagFileDigestAlgosTagVariantsTagXMajorTagXMinorTagRepoTagTagKeywordsTagBuildPlatformsTagPackageColorTagPackagePrefColorTagXAttrsDictTagFileXAttrsxTagDepAttrsDictTagConflictAttrsXTagObsoleteAttrsXTagProvideAttrsXTagRequireAttrsXTagBuildProvidesTagBuildObsoletesTagDbInstanceTagNVRA" _Tag_name_8 = "TagFilenamesTagFileProvideTagFileRequireTagFsNamesTagFsFizesTagTriggerCondsTagTriggerTypeTagOrigFileNamesTagLongFileSizesTagLongSizeTagFileCapsTagFileDigestAlgoTagBugURLTagEVRTagNVRTagNEVRTagNEVRATagHeaderColorTagVerboseTagEpochNumTagPreInstallFlagsTagPostInstallFlagsTagPreUninstallFlagsTagPostUninstallFlagsTagPreTransFlagsTagPostTransFlagsTagVerifyScriptFlagsTagTriggerScriptFlags" - _Tag_name_9 = "TagCollectionsTagPolicyNamesTagPolicyTypesTagPolicyTypesIndexesTagPolicyFlagsTagVCSTagOrderNameTagOrderVersionTagOrderFlagsTagMSSFManifestTagMSSFDomainTagInstFilenamesTagRequireNEVRSTagProvideNEVRSTagObsoleteNEVRSTagConflictNEVRSTagFileNLinksTagRecommendNameTagRecommendVersionTagRecommendFlagsTagSuggestNameTagSuggestVersionTagSuggestFlagsTagSupplementNameTagSupplementVersionTagSupplementFlagsTagEnhanceNameTagEnhanceVersionTagEnhanceFlagsTagRecommendNEVRSTagSuggestNEVRSTagSupplementNEVRSTagEnhanceNEVRSTagEncodingTagFileTriggerInstallTagFileTriggerUninstallTagFileTriggerPostUninstallTagFileTriggerScriptsTagFileTriggerScriptProgTagFileTriggerScriptFlagsTagFileTriggerNameTagFileTriggerIndexTagFileTriggerVersionTagFileTriggerFlagsTagTransFileTriggerInstallTagTransFileTriggerUninstallTagTransFileTriggerPostUninstallTagTransFileTriggerScriptsTagTransFileTriggerScriptProgTagTransFileTriggerScriptFlagsTagTransFileTriggerNameTagTransFileTriggerIndexTagTransFileTriggerVersionTagTransFileTriggerFlagsTagRemovePathPostFixesTagFileTriggerPrioritiesTagTransFileTriggerPrioritiesTagFileTriggerCondsTagFileTriggerTypeTagTransFileTriggerCondsTagTransFileTriggerTypeTagFileSignaturesTagFileSignatureLengthTagPayloadDigestTagPayloadDigestAlgoTagAutoInstalledTagIdentityTagModularityLabelTagPayloadDigestAltTagArchSuffix" + _Tag_name_9 = "TagCollectionsTagPolicyNamesTagPolicyTypesTagPolicyTypesIndexesTagPolicyFlagsTagVCSTagOrderNameTagOrderVersionTagOrderFlagsTagMSSFManifestTagMSSFDomainTagInstFilenamesTagRequireNEVRSTagProvideNEVRSTagObsoleteNEVRSTagConflictNEVRSTagFileNLinksTagRecommendNameTagRecommendVersionTagRecommendFlagsTagSuggestNameTagSuggestVersionTagSuggestFlagsTagSupplementNameTagSupplementVersionTagSupplementFlagsTagEnhanceNameTagEnhanceVersionTagEnhanceFlagsTagRecommendNEVRSTagSuggestNEVRSTagSupplementNEVRSTagEnhanceNEVRSTagEncodingTagFileTriggerInstallTagFileTriggerUninstallTagFileTriggerPostUninstallTagFileTriggerScriptsTagFileTriggerScriptProgTagFileTriggerScriptFlagsTagFileTriggerNameTagFileTriggerIndexTagFileTriggerVersionTagFileTriggerFlagsTagTransFileTriggerInstallTagTransFileTriggerUninstallTagTransFileTriggerPostUninstallTagTransFileTriggerScriptsTagTransFileTriggerScriptProgTagTransFileTriggerScriptFlagsTagTransFileTriggerNameTagTransFileTriggerIndexTagTransFileTriggerVersionTagTransFileTriggerFlagsTagRemovePathPostFixesTagFileTriggerPrioritiesTagTransFileTriggerPrioritiesTagFileTriggerCondsTagFileTriggerTypeTagTransFileTriggerCondsTagTransFileTriggerTypeTagFileSignaturesTagFileSignatureLengthTagPayloadDigestTagPayloadDigestAlgoTagAutoInstalledTagIdentityTagModularityLabelTagPayloadDigestAltTagArchSuffixTagSpecTagTranslationURLTagUpstreamReleasesTagSourceLicenseTagPreUntransTagPostUntransTagPreUntransProgTagPostUntransProgTagPreUntransFlagsTagPostUntransFlagsTagSysusersTagBuildSystemTagBuildOptionTagPayloadSizeTagPayloadSizeAltTagRPMFormatTagFileMimeIndexTagMimeDictTagFileMimesTagPackageDigestsTagPackageDigestAlgos" ) var ( @@ -341,7 +362,7 @@ var ( _Tag_index_6 = [...]uint16{0, 7, 17, 27, 35, 45, 59, 71, 83, 97, 104, 119, 128, 134, 140, 150, 161, 169, 181, 190, 198, 204, 209, 216, 229, 243, 258, 274, 289, 301, 314, 326, 337, 348, 360, 373, 387, 401, 413, 420, 435, 451, 461, 473, 480, 492, 510, 524, 538, 553, 567, 584, 595, 605, 621, 636, 654, 670, 682, 698, 712, 724, 740, 754, 768, 781, 798, 812, 829, 844, 859} _Tag_index_7 = [...]uint16{0, 15, 31, 47, 63, 75, 84, 101, 119, 138, 158, 171, 186, 205, 225, 234, 243, 257, 270, 282, 293, 311, 328, 347, 370, 380, 391, 404, 420, 443, 457, 473, 490, 504, 519, 536, 552, 570, 583, 595, 606, 623, 639, 654, 665, 675, 691, 711, 726, 741, 754, 766, 776, 790, 801, 815, 830, 847, 860, 875, 890, 906, 919, 931, 943, 958, 973, 987, 1001, 1016, 1029, 1042, 1053, 1064, 1076, 1091, 1107, 1117, 1135, 1156, 1175, 1193, 1214, 1233, 1244, 1252, 1265, 1278, 1291, 1304, 1317, 1330, 1346, 1366, 1382, 1398, 1413, 1429, 1445, 1463, 1474, 1483, 1492, 1502, 1513, 1530, 1545, 1564, 1577, 1591, 1606, 1623, 1640, 1656, 1672, 1688, 1705, 1718, 1725} _Tag_index_8 = [...]uint16{0, 12, 26, 40, 50, 60, 75, 89, 105, 121, 132, 143, 160, 169, 175, 181, 188, 196, 210, 220, 231, 249, 268, 288, 309, 325, 342, 362, 383} - _Tag_index_9 = [...]uint16{0, 14, 28, 42, 63, 77, 83, 95, 110, 123, 138, 151, 167, 182, 197, 213, 229, 242, 258, 277, 294, 308, 325, 340, 357, 377, 395, 409, 426, 441, 458, 473, 491, 506, 517, 538, 561, 588, 609, 633, 658, 676, 695, 716, 735, 761, 789, 821, 847, 876, 906, 929, 953, 979, 1003, 1025, 1049, 1078, 1097, 1115, 1139, 1162, 1179, 1201, 1217, 1237, 1253, 1264, 1282, 1301, 1314} + _Tag_index_9 = [...]uint16{0, 14, 28, 42, 63, 77, 83, 95, 110, 123, 138, 151, 167, 182, 197, 213, 229, 242, 258, 277, 294, 308, 325, 340, 357, 377, 395, 409, 426, 441, 458, 473, 491, 506, 517, 538, 561, 588, 609, 633, 658, 676, 695, 716, 735, 761, 789, 821, 847, 876, 906, 929, 953, 979, 1003, 1025, 1049, 1078, 1097, 1115, 1139, 1162, 1179, 1201, 1217, 1237, 1253, 1264, 1282, 1301, 1314, 1321, 1338, 1357, 1373, 1386, 1400, 1417, 1435, 1453, 1472, 1483, 1497, 1511, 1525, 1542, 1554, 1570, 1581, 1593, 1610, 1631} ) func (i Tag) String() string { @@ -370,7 +391,7 @@ func (i Tag) String() string { case 5000 <= i && i <= 5027: i -= 5000 return _Tag_name_8[_Tag_index_8[i]:_Tag_index_8[i+1]] - case 5029 <= i && i <= 5098: + case 5029 <= i && i <= 5119: i -= 5029 return _Tag_name_9[_Tag_index_9[i]:_Tag_index_9[i+1]] default: diff --git a/rpm/internal/rpm/tag_table.go b/internal/rpm/rpmdb/tag_table.go similarity index 91% rename from rpm/internal/rpm/tag_table.go rename to internal/rpm/rpmdb/tag_table.go index fab4afb0e..79acbde60 100644 --- a/rpm/internal/rpm/tag_table.go +++ b/internal/rpm/rpmdb/tag_table.go @@ -1,4 +1,4 @@ -package rpm +package rpmdb type tagTab struct { Short string @@ -240,6 +240,27 @@ var tagTable = [...]tagTab{ {"Modularitylabel", TagModularityLabel, TypeString, returnScalar, false}, {"Payloaddigestalt", TagPayloadDigestAlt, TypeStringArray, returnArray, false}, {"Archsuffix", TagArchSuffix, TypeString, returnScalar, true}, + {"Spec", TagSpec, TypeString, returnScalar, false}, + {"Translationurl", TagTranslationURL, TypeString, returnScalar, false}, + {"Upstreamreleases", TagUpstreamReleases, TypeString, returnScalar, false}, + {"Sourcelicense", TagSourceLicense, TypeString, returnScalar, false}, + {"Preuntrans", TagPreUntrans, TypeString, returnScalar, false}, + {"Postuntrans", TagPostUntrans, TypeString, returnScalar, false}, + {"Preuntransprog", TagPreUntransProg, TypeString, returnArray, false}, + {"Postuntransprog", TagPostUntransProg, TypeString, returnArray, false}, + {"Preuntransflags", TagPreUntransFlags, TypeInt32, returnScalar, false}, + {"Postuntransflags", TagPostUntransFlags, TypeInt32, returnScalar, false}, + {"Sysusers", TagSysusers, TypeString, returnArray, true}, + {"Buildsystem", TagBuildSystem, TypeString, returnScalar, false}, + {"Buildoption", TagBuildOption, TypeString, returnScalar, false}, + {"Payloadsize", TagPayloadSize, TypeInt64, returnScalar, false}, + {"Payloadsizealt", TagPayloadSizeAlt, TypeInt64, returnScalar, false}, + {"Rpmformat", TagRPMFormat, TypeInt32, returnScalar, false}, + {"Filemimeindex", TagFileMimeIndex, TypeInt32, returnArray, false}, + {"Mimedict", TagMimeDict, TypeString, returnArray, false}, + {"Filemimes", TagFileMimes, TypeString, returnArray, true}, + {"Packagedigests", TagPackageDigests, TypeString, returnArray, false}, + {"Packagedigestalgos", TagPackageDigestAlgos, TypeInt32, returnArray, false}, } var tagByValue map[Tag]int diff --git a/rpm/internal/rpm/testdata/package.header b/internal/rpm/rpmdb/testdata/package.header similarity index 100% rename from rpm/internal/rpm/testdata/package.header rename to internal/rpm/rpmdb/testdata/package.header diff --git a/rpm/sqlite/sql/allpackages.sql b/internal/rpm/sqlite/sql/allpackages.sql similarity index 100% rename from rpm/sqlite/sql/allpackages.sql rename to internal/rpm/sqlite/sql/allpackages.sql diff --git a/rpm/sqlite/sql/validate.sql b/internal/rpm/sqlite/sql/validate.sql similarity index 100% rename from rpm/sqlite/sql/validate.sql rename to internal/rpm/sqlite/sql/validate.sql diff --git a/rpm/sqlite/sqlite.go b/internal/rpm/sqlite/sqlite.go similarity index 67% rename from rpm/sqlite/sqlite.go rename to internal/rpm/sqlite/sqlite.go index 2fa42a6ac..aab725a6b 100644 --- a/rpm/sqlite/sqlite.go +++ b/internal/rpm/sqlite/sqlite.go @@ -9,6 +9,7 @@ import ( "errors" "fmt" "io" + "iter" "net/url" "runtime" @@ -63,30 +64,35 @@ func (db *RPMDB) Close() error { return db.db.Close() } -// AllHeaders returns ReaderAts for all RPM headers in the database. -func (db *RPMDB) AllHeaders(ctx context.Context) ([]io.ReaderAt, error) { +// Headers returns an iterator over all RPM headers in the database. +func (db *RPMDB) Headers(ctx context.Context) iter.Seq2[io.ReaderAt, error] { // Keys are sorted coming out of this query. rows, err := db.db.QueryContext(ctx, allpackages) - if err != nil { - return nil, err - } - defer rows.Close() - var r []io.ReaderAt - var hnum int64 - for rows.Next() { - blob := make([]byte, 0, 4*4096) // Eyeballing a good initial capacity; do some profiling. - // As an alternative, this function could allocate one large buffer and subslice it for each - // Scan call, then use io.SectionReaders for the returned []io.ReaderAt. - if err := rows.Scan(&hnum, &blob); err != nil { - return nil, fmt.Errorf("sqlite: scan error: %w", err) + return func(yield func(io.ReaderAt, error) bool) { + if err != nil { + yield(nil, err) + return + } + defer rows.Close() + var hnum int64 + for rows.Next() { + blob := make([]byte, 0, 4096) // Eyeballing a good initial capacity; do some profiling. + // As an alternative, this function could allocate one large buffer and subslice it for each + // Scan call, then use io.SectionReaders for the returned []io.ReaderAt. + if err := rows.Scan(&hnum, &blob); err != nil { + if !yield(nil, fmt.Errorf("sqlite: scan error: %w", err)) { + return + } + continue + } + if !yield(bytes.NewReader(blob), nil) { + return + } + } + if err := rows.Err(); err != nil { + yield(nil, fmt.Errorf("sqlite: sql error: %w", err)) } - r = append(r, bytes.NewReader(blob)) - } - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("sqlite: sql error: %w", err) } - - return r, nil } func (db *RPMDB) Validate(ctx context.Context) error { diff --git a/rpm/sqlite/sqlite_test.go b/internal/rpm/sqlite/sqlite_test.go similarity index 95% rename from rpm/sqlite/sqlite_test.go rename to internal/rpm/sqlite/sqlite_test.go index 62c9dcd89..e22ed6c75 100644 --- a/rpm/sqlite/sqlite_test.go +++ b/internal/rpm/sqlite/sqlite_test.go @@ -66,12 +66,13 @@ func TestPackages(t *testing.T) { t.Error(err) } - hdrs, err := db.AllHeaders(ctx) - if err != nil { - t.Error(err) - } var got []uint64 - for _, rd := range hdrs { + for rd, err := range db.Headers(ctx) { + if err != nil { + t.Error(err) + got = append(got, 0) + continue + } h.Reset() if _, err := io.Copy(h, rd.(io.Reader)); err != nil { t.Error(err) diff --git a/rpm/sqlite/testdata/no_packages.sqlite b/internal/rpm/sqlite/testdata/no_packages.sqlite similarity index 100% rename from rpm/sqlite/testdata/no_packages.sqlite rename to internal/rpm/sqlite/testdata/no_packages.sqlite diff --git a/rpm/sqlite/testdata/rpmdb.sqlite b/internal/rpm/sqlite/testdata/rpmdb.sqlite similarity index 100% rename from rpm/sqlite/testdata/rpmdb.sqlite rename to internal/rpm/sqlite/testdata/rpmdb.sqlite diff --git a/rpm/sqlite/testdata/rpmdb.sqlite.checksums b/internal/rpm/sqlite/testdata/rpmdb.sqlite.checksums similarity index 100% rename from rpm/sqlite/testdata/rpmdb.sqlite.checksums rename to internal/rpm/sqlite/testdata/rpmdb.sqlite.checksums diff --git a/java/packagescanner.go b/java/packagescanner.go index bed117270..457cc1cbd 100644 --- a/java/packagescanner.go +++ b/java/packagescanner.go @@ -149,13 +149,13 @@ func (s *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*claircor ck := make([]byte, sha1.Size) doSearch := s.root != nil defer putBuf(buf) - fc, err := rpm.NewFileChecker(ctx, layer) + set, err := rpm.NewPathSet(ctx, layer) if err != nil { return nil, fmt.Errorf("java: unable to check RPM db: %w", err) } for _, n := range ars { ctx := zlog.ContextWithValues(ctx, "file", n) - if fc.IsRPM(n) { + if set.Contains(n) { zlog.Debug(ctx). Str("path", n). Msg("file path determined to be of RPM origin") diff --git a/nodejs/packagescanner.go b/nodejs/packagescanner.go index 68b39817a..9c56be593 100644 --- a/nodejs/packagescanner.go +++ b/nodejs/packagescanner.go @@ -92,13 +92,13 @@ func (s *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*claircor ret := make([]*claircore.Package, 0, len(pkgs)) var invalidPkgs []string - fc, err := rpm.NewFileChecker(ctx, layer) + set, err := rpm.NewPathSet(ctx, layer) if err != nil { return nil, fmt.Errorf("nodejs: unable to check RPM db: %w", err) } for _, p := range pkgs { - if fc.IsRPM(p) { + if set.Contains(p) { zlog.Debug(ctx). Str("path", p). Msg("file path determined to be of RPM origin") diff --git a/python/packagescanner.go b/python/packagescanner.go index b13269a58..6f6eb8d96 100644 --- a/python/packagescanner.go +++ b/python/packagescanner.go @@ -79,12 +79,12 @@ func (ps *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*clairco return nil, fmt.Errorf("python: failed to find delicious egg: %w", err) } var ret []*claircore.Package - fc, err := rpm.NewFileChecker(ctx, layer) + set, err := rpm.NewPathSet(ctx, layer) if err != nil { return nil, fmt.Errorf("python: unable to check RPM db: %w", err) } for _, n := range ms { - if fc.IsRPM(n) { + if set.Contains(n) { zlog.Debug(ctx). Str("path", n). Msg("file path determined to be of RPM origin") diff --git a/rhel/coalescer.go b/rhel/coalescer.go index 2e1ab9046..3b9308759 100644 --- a/rhel/coalescer.go +++ b/rhel/coalescer.go @@ -2,22 +2,21 @@ package rhel import ( "context" + "net/url" "github.com/quay/claircore" "github.com/quay/claircore/indexer" ) -/* -Coalescer takes individual layer artifacts and coalesces them into a full report -on the manifest's contents. - -Due to the specifics of the RHEL build system, some information needs to be -back-propagated. That is to say, some information discovered in later layers is -also attributed to earlier layers. Both the product and distribution information -work this way. - -A Coalescer is safe for concurrent use. -*/ +// Coalescer takes individual layer artifacts and coalesces them into a full +// report on the manifest's contents. +// +// Due to the specifics of the RHEL build system, some information needs to be +// back-propagated. That is to say, some information discovered in later layers +// is also attributed to earlier layers. Both the product and distribution +// information work this way. +// +// A Coalescer is safe for concurrent use. type Coalescer struct{} var _ indexer.Coalescer = (*Coalescer)(nil) @@ -50,6 +49,10 @@ func (*Coalescer) Coalesce(ctx context.Context, artifacts []*indexer.LayerArtifa } // The same thing has to be done in reverse, because the first layer(s) are missing // the relevant information. + // + // With [ENGCMP-5332], this shouldn't be needed, so check back in 5 years. + // + // [ENGCMP-5332]: https://issues.redhat.com/browse/ENGCMP-5332 for i := len(artifacts) - 1; i >= 0; i-- { lr := filterRedHatRepos(artifacts[i].Repos) if len(lr) != 0 { @@ -61,14 +64,18 @@ func (*Coalescer) Coalesce(ctx context.Context, artifacts []*indexer.LayerArtifa // This dance with copying the product information in both directions means // that if Red Hat product information is found, it "taints" all the layers. + // Break the key-by-ID convention because we need to talk about the repoid + // in the package matching step. for _, a := range artifacts { for _, repo := range a.Repos { - ir.Repositories[repo.ID] = repo + ir.Repositories[repo.Name] = repo } } // In our coalescing logic if a Distribution is found in layer "n" all packages found - // in layers [0-n] will be associated with this layer. This is for the same reasons + // in layers 0..n will be associated with this layer. This is for the same reasons // for the repository tainting, above. + // + // This may not be needed because of matcher changes. var curDist *claircore.Distribution for _, a := range artifacts { if len(a.Dist) != 0 { @@ -77,18 +84,19 @@ func (*Coalescer) Coalesce(ctx context.Context, artifacts []*indexer.LayerArtifa break } } - // Next lets begin associating packages with their Environment. We must - // consider each package in a package database as a unique entity for - // the edge case where a unique package is located in more then one package database. - // we'll use a struct as a helper and a map to lookup these structs + // Next, let's begin associating packages with their Environment. We must + // consider each package in a package database as a unique entity for the + // edge case where a unique package is located in more then one package + // database. We'll use a struct as a helper and a map to lookup these + // structs. type packageDatabase struct { packages map[string]*claircore.Package environments map[string]*claircore.Environment } dbs := map[string]*packageDatabase{} - // lets walk each layer forward looking for packages, new distributions, and - // creating the environments we discover packages in. + // Let's walk each layer forward looking for packages, new distributions, + // and creating the environments we discover packages in. for _, layerArtifacts := range artifacts { // check if we need to update our currDist if len(layerArtifacts.Dist) != 0 { @@ -116,10 +124,15 @@ func (*Coalescer) Coalesce(ctx context.Context, artifacts []*indexer.LayerArtifa PackageDB: pkg.PackageDB, IntroducedIn: layerArtifacts.Hash, DistributionID: distID, - RepositoryIDs: make([]string, len(layerArtifacts.Repos)), } - for i := range layerArtifacts.Repos { - environment.RepositoryIDs[i] = layerArtifacts.Repos[i].ID + v, _ := url.ParseQuery(pkg.RepositoryHint) + if id := v.Get("repoid"); id != "" { + environment.RepositoryIDs = v["repoid"] + } else { + environment.RepositoryIDs = make([]string, len(layerArtifacts.Repos)) + for i := range layerArtifacts.Repos { + environment.RepositoryIDs[i] = layerArtifacts.Repos[i].Name + } } db.packages[pkg.ID] = pkg db.environments[pkg.ID] = environment @@ -133,21 +146,20 @@ func (*Coalescer) Coalesce(ctx context.Context, artifacts []*indexer.LayerArtifa // Now let's go through packages and finds out whether each package is still // available in package database in higher layers. // When package is not available in higher layers it means that package was - // either updated/downgraded/removed. In such a cases we need to remove it - // from list of packages + // either updated/downgraded/removed. // If a package is available in all layers it means that it should be added - // to list of packages and associate an environment for it. - for i := range artifacts { - currentLayerArtifacts := artifacts[i] + // to the list of packages and associate an environment for it. + for i, currentLayerArtifacts := range artifacts { if len(currentLayerArtifacts.Pkgs) == 0 { continue } for _, currentPkg := range currentLayerArtifacts.Pkgs { if _, ok := ir.Packages[currentPkg.ID]; ok { - // the package was already processed in previous layers + // The package was already processed in previous layers. continue } - // for each package let's find out if it is also available in other layers dbs + // For each package, let's find out if it is also available in other + // layer's dbs. found := true for j := i + 1; j < len(artifacts); j++ { nextLayerArtifacts := artifacts[j] diff --git a/rhel/coalescer_test.go b/rhel/coalescer_test.go index 946f9452d..6eb6c7876 100644 --- a/rhel/coalescer_test.go +++ b/rhel/coalescer_test.go @@ -2,9 +2,13 @@ package rhel import ( "context" - "strconv" + "fmt" + "net/url" "testing" + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/quay/claircore/toolkit/types/cpe" "github.com/quay/zlog" "github.com/quay/claircore" @@ -12,330 +16,448 @@ import ( "github.com/quay/claircore/test" ) -// TestCoalescer tests the private method coalesce on the rhel.Coalescer. -// it's simpler to test the core business logic of a rhel.Coalescer after -// database access would have occurred. Thus we do not use a black box test -// and instead test private methods. -func TestCoalescer(t *testing.T) { - ctx := zlog.Test(context.Background(), t) - coalescer := new(Coalescer) - // we will test - // 1) packages before a distribution was discovered are tagged with - // the first distribution found - // 2) all packages found after a subsequent distribution is located - // are tagged with this distribution - pkgs := test.GenUniquePackages(6) - dists := test.GenUniqueDistributions(3) // we will discard dist 0 due to zero value ambiguity - layerArtifacts := []*indexer.LayerArtifacts{ - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:1], - Dist: nil, - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:2], - Dist: nil, - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:3], - Dist: dists[1:2], - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:4], - Dist: nil, - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:5], - Dist: dists[2:], - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:], - Dist: nil, - Repos: nil, - }, - } - ir, err := coalescer.Coalesce(ctx, layerArtifacts) - if err != nil { - t.Fatalf("received error from coalesce method: %v", err) - } - // we expect packages 1-4 to be tagged with dist id 1 - // and packages 5-6 to be tagged with dist id 2 - for i := 0; i < 4; i++ { - environment := ir.Environments[strconv.Itoa(i)][0] - if environment.DistributionID != "1" { - t.Fatalf("expected distribution id %d but got %s", 1, environment.DistributionID) - } - } - for i := 4; i < 6; i++ { - environment := ir.Environments[strconv.Itoa(i)][0] - if environment.DistributionID != "2" { - t.Fatalf("expected distribution id %d but got %s", 2, environment.DistributionID) - } - } +type CoalescerTestcase struct { + Name string + Fixture func(testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) } -func TestCoalescerCPERepos(t *testing.T) { - ctx := zlog.Test(context.Background(), t) - coalescer := new(Coalescer) - repo1 := &claircore.Repository{ - ID: "1", - Name: "rhel-8-for-x86_64-baseos-rpms", - Key: repositoryKey, - } - repo2 := &claircore.Repository{ - ID: "2", - Name: "rhel-8-for-x86_64-appstream-rpms", - Key: repositoryKey, - } - repo3 := &claircore.Repository{ - ID: "3", - Name: "rhel-8-for-x86_64-appstream-rpms", - Key: repositoryKey, - } - - pkgs := test.GenUniquePackages(5) - dists := test.GenUniqueDistributions(3) // we will discard dist 0 due to zero value ambiguity - layerArtifacts := []*indexer.LayerArtifacts{ - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:1], - Dist: nil, - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:2], - Dist: nil, - Repos: []*claircore.Repository{repo1, repo2}, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:3], - Dist: dists[1:2], - Repos: []*claircore.Repository{repo3}, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:4], - Dist: nil, - Repos: nil, - }, - { - Hash: test.RandomSHA256Digest(t), - Pkgs: pkgs[0:5], - Dist: dists[2:], - Repos: nil, - }, - } - ir, err := coalescer.Coalesce(ctx, layerArtifacts) - if err != nil { - t.Fatalf("received error from coalesce method: %v", err) - } - // we expect packages 1-2 to be associated with repos 1 and 2 - for i := 0; i < 2; i++ { - environment := ir.Environments[strconv.Itoa(i)][0] - if len(environment.RepositoryIDs) != 2 || environment.RepositoryIDs[0] != "1" || environment.RepositoryIDs[1] != "2" { - t.Fatalf("expected repository ids [1, 2] but got %s", environment.RepositoryIDs) +func (tc CoalescerTestcase) Run(ctx context.Context, t *testing.T) { + t.Run(tc.Name, func(t *testing.T) { + ctx := zlog.Test(ctx, t) + input, want := tc.Fixture(t) + got, err := new(Coalescer).Coalesce(ctx, input) + if err != nil { + t.Fatal(err) } - } - // and packages 3-5 to be associated with repo 3 - for i := 2; i < 5; i++ { - environment := ir.Environments[strconv.Itoa(i)][0] - if len(environment.RepositoryIDs) != 1 || environment.RepositoryIDs[0] != "3" { - t.Fatalf("expected repository ids [3] but got %s", environment.RepositoryIDs) + opts := cmp.Options{cmpopts.IgnoreUnexported(claircore.Digest{})} + if !cmp.Equal(got, want, opts) { + t.Error(cmp.Diff(got, want, opts)) } - } + }) } -func TestCoalescerUpdatedPackage(t *testing.T) { +func TestCoalescer(t *testing.T) { + t.Parallel() ctx := zlog.Test(context.Background(), t) - coalescer := new(Coalescer) - repo1 := &claircore.Repository{ - ID: "1", - Name: "cpe:/o:redhat:enterprise_linux:8::baseos", - Key: "rhel-cpe-repo", - } - repo2 := &claircore.Repository{ - ID: "2", - Name: "cpe:/o:redhat:enterprise_linux:8::appstream", - Key: "rhel-cpe-repo", - } - pkg1 := &claircore.Package{ - ID: "1", - Name: "foo", - Version: "1.0-1", - PackageDB: "/var/lib/rpm", - } - pkg2 := &claircore.Package{ - ID: "2", - Name: "foo", - Version: "2.0-1", - PackageDB: "/var/lib/rpm", - } - layerArtifacts := []*indexer.LayerArtifacts{ - { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg1}, - Dist: nil, - Repos: []*claircore.Repository{repo1}, - }, + + tcs := []CoalescerTestcase{ { - Hash: test.RandomSHA256Digest(t), - Pkgs: nil, - Dist: nil, - Repos: nil, + Name: "Simple", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + pkgs := test.GenUniquePackages(6) + // Discard dist 0 due to zero value ambiguity. + dists := test.GenUniqueDistributions(3) + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:1], + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:2], + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:3], + Dist: dists[1:2], + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:4], + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:5], + Dist: dists[2:], + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:], + Dist: nil, + Repos: nil, + }, + } + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{}, + Distributions: map[string]*claircore.Distribution{ + dists[1].ID: dists[1], + dists[2].ID: dists[2], + }, + Repositories: map[string]*claircore.Repository{}, + Environments: map[string][]*claircore.Environment{}, + } + for i, pkg := range pkgs { + k := fmt.Sprint(i) + want.Environments[k] = []*claircore.Environment{ + { + PackageDB: fmt.Sprintf("package-db-%d", i), + RepositoryIDs: []string{}, + }, + } + switch i { + case 0, 1, 2, 3: + want.Environments[k][0].DistributionID = dists[1].ID + case 4, 5: + want.Environments[k][0].DistributionID = dists[2].ID + } + want.Packages[pkg.ID] = pkg + } + + return input, want + }, }, { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg2}, - Dist: nil, - Repos: []*claircore.Repository{repo2}, - }, - } - ir, err := coalescer.Coalesce(ctx, layerArtifacts) - if err != nil { - t.Fatalf("received error from coalesce method: %v", err) - } - if _, ok := ir.Packages[pkg1.ID]; ok { - t.Fatalf("Package %v was updated to %v, but previous version is still available", pkg1, pkg2) - } - if _, ok := ir.Environments[pkg1.ID]; ok { - t.Fatalf("Package %v was updated to %v, but previous version is still available in environment", pkg1, pkg2) - } - if _, ok := ir.Packages[pkg2.ID]; !ok { - t.Fatalf("Package %v was updated to %v, but new version is not available", pkg1, pkg2) - } - if _, ok := ir.Environments[pkg2.ID]; !ok { - t.Fatalf("Package %v was updated to %v, but new version is still not available in environment", pkg1, pkg2) - } -} + Name: "CPERepos", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + repo1 := &claircore.Repository{ + ID: "1", + Name: "rhel-8-for-x86_64-baseos-rpms", + Key: repositoryKey, + } + repo2 := &claircore.Repository{ + ID: "2", + Name: "rhel-8-for-x86_64-appstream-rpms", + Key: repositoryKey, + } + repo3 := &claircore.Repository{ + ID: "3", + Name: "rhel-8-for-x86_64-appstream-rpms", + Key: repositoryKey, + } + pkgs := test.GenUniquePackages(5) + // Discard dist 0 due to zero value ambiguity. + dists := test.GenUniqueDistributions(3) -func TestCoalescerDowngradedPackage(t *testing.T) { - ctx := zlog.Test(context.Background(), t) - coalescer := new(Coalescer) - repo1 := &claircore.Repository{ - ID: "1", - Name: "cpe:/o:redhat:enterprise_linux:8::baseos", - Key: "rhel-cpe-repo", - } - repo2 := &claircore.Repository{ - ID: "2", - Name: "cpe:/o:redhat:enterprise_linux:8::appstream", - Key: "rhel-cpe-repo", - } - pkg1 := &claircore.Package{ - ID: "1", - Name: "foo", - Version: "1.0-1", - PackageDB: "/var/lib/rpm", - } - pkg2 := &claircore.Package{ - ID: "2", - Name: "foo", - Version: "2.0-1", - PackageDB: "/var/lib/rpm", - } - layerArtifacts := []*indexer.LayerArtifacts{ - { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg2}, - Dist: nil, - Repos: []*claircore.Repository{repo1}, + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:1], + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:2], + Dist: nil, + Repos: []*claircore.Repository{repo1, repo2}, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:3], + Dist: dists[1:2], + Repos: []*claircore.Repository{repo3}, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:4], + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: pkgs[0:5], + Dist: dists[2:], + Repos: nil, + }, + } + + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{}, + Distributions: map[string]*claircore.Distribution{ + dists[1].ID: dists[1], + dists[2].ID: dists[2], + }, + Repositories: map[string]*claircore.Repository{ + repo3.Name: repo3, + repo1.Name: repo1, + }, + Environments: map[string][]*claircore.Environment{}, + } + for i, pkg := range pkgs { + k := fmt.Sprint(i) + want.Environments[k] = []*claircore.Environment{ + { + PackageDB: fmt.Sprintf("package-db-%d", i), + }, + } + switch i { + case 0, 1: + want.Environments[k][0].RepositoryIDs = []string{repo1.Name, repo2.Name} + case 2, 3, 4: + want.Environments[k][0].RepositoryIDs = []string{repo3.Name} + } + switch i { + case 0, 1, 2, 3: + want.Environments[k][0].DistributionID = dists[1].ID + case 4: + want.Environments[k][0].DistributionID = dists[2].ID + } + want.Packages[pkg.ID] = pkg + } + + return input, want + }, }, { - Hash: test.RandomSHA256Digest(t), - Pkgs: nil, - Dist: nil, - Repos: nil, + Name: "UpgradedPackage", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + repo1 := &claircore.Repository{ + ID: "1", + Name: "cpe:/o:redhat:enterprise_linux:8::baseos", + Key: repositoryKey, + } + repo2 := &claircore.Repository{ + ID: "2", + Name: "cpe:/o:redhat:enterprise_linux:8::appstream", + Key: repositoryKey, + } + pkg1 := &claircore.Package{ + ID: "1", + Name: "foo", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + } + pkg2 := &claircore.Package{ + ID: "2", + Name: "foo", + Version: "2.0-1", + PackageDB: "fixture:/var/lib/rpm", + } + + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg1}, + Dist: nil, + Repos: []*claircore.Repository{repo1}, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: nil, + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg2}, + Dist: nil, + Repos: []*claircore.Repository{repo2}, + }, + } + + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{pkg2.ID: pkg2}, + Distributions: map[string]*claircore.Distribution{}, + Repositories: map[string]*claircore.Repository{ + repo2.Name: repo2, + repo1.Name: repo1, + }, + Environments: map[string][]*claircore.Environment{ + pkg2.ID: { + { + PackageDB: pkg2.PackageDB, + RepositoryIDs: []string{repo2.Name}, + }, + }, + }, + } + + return input, want + }, }, { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg1}, - Dist: nil, - Repos: []*claircore.Repository{repo2}, - }, - } - ir, err := coalescer.Coalesce(ctx, layerArtifacts) - if err != nil { - t.Fatalf("received error from coalesce method: %v", err) - } - if _, ok := ir.Packages[pkg2.ID]; ok { - t.Fatalf("Package %v was downgraded to %v, but previous version is still available", pkg2, pkg1) - } - if _, ok := ir.Environments[pkg2.ID]; ok { - t.Fatalf("Package %v was downgraded to %v, but previous version is still available in environment", pkg2, pkg1) - } - if _, ok := ir.Packages[pkg1.ID]; !ok { - t.Fatalf("Package %v was downgraded to %v, but new version is not available", pkg2, pkg1) - } - if _, ok := ir.Environments[pkg1.ID]; !ok { - t.Fatalf("Package %v was downgraded to %v, but new version is still not available in environment", pkg2, pkg1) - } -} + Name: "DowngradedPackage", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + repo1 := &claircore.Repository{ + ID: "1", + Name: "cpe:/o:redhat:enterprise_linux:8::baseos", + Key: repositoryKey, + } + repo2 := &claircore.Repository{ + ID: "2", + Name: "cpe:/o:redhat:enterprise_linux:8::appstream", + Key: repositoryKey, + } + pkg1 := &claircore.Package{ + ID: "1", + Name: "foo", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + } + pkg2 := &claircore.Package{ + ID: "2", + Name: "bar", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + } -func TestCoalescerRemovedPackage(t *testing.T) { - ctx := zlog.Test(context.Background(), t) - coalescer := new(Coalescer) - repo1 := &claircore.Repository{ - ID: "1", - Name: "cpe:/o:redhat:enterprise_linux:8::baseos", - Key: "rhel-cpe-repo", - } - repo2 := &claircore.Repository{ - ID: "2", - Name: "cpe:/o:redhat:enterprise_linux:8::appstream", - Key: "rhel-cpe-repo", - } - pkg1 := &claircore.Package{ - ID: "1", - Name: "foo", - Version: "1.0-1", - PackageDB: "/var/lib/rpm", - } - pkg2 := &claircore.Package{ - ID: "2", - Name: "bar", - Version: "1.0-1", - PackageDB: "/var/lib/rpm", - } - layerArtifacts := []*indexer.LayerArtifacts{ - { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg1}, - Dist: nil, - Repos: []*claircore.Repository{repo1}, + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg2}, + Dist: nil, + Repos: []*claircore.Repository{repo1}, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: nil, + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg1}, + Dist: nil, + Repos: []*claircore.Repository{repo2}, + }, + } + + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{pkg1.ID: pkg1}, + Distributions: map[string]*claircore.Distribution{}, + Repositories: map[string]*claircore.Repository{ + repo2.Name: repo2, + repo1.Name: repo1, + }, + Environments: map[string][]*claircore.Environment{ + pkg1.ID: { + { + PackageDB: pkg1.PackageDB, + RepositoryIDs: []string{repo2.Name}, + }, + }, + }, + } + + return input, want + }, }, { - Hash: test.RandomSHA256Digest(t), - Pkgs: nil, - Dist: nil, - Repos: nil, + Name: "RemovedPackage", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + repo1 := &claircore.Repository{ + ID: "1", + Name: "cpe:/o:redhat:enterprise_linux:8::baseos", + Key: repositoryKey, + } + repo2 := &claircore.Repository{ + ID: "2", + Name: "cpe:/o:redhat:enterprise_linux:8::appstream", + Key: repositoryKey, + } + pkg1 := &claircore.Package{ + ID: "1", + Name: "foo", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + } + pkg2 := &claircore.Package{ + ID: "2", + Name: "bar", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + } + + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg1}, + Dist: nil, + Repos: []*claircore.Repository{repo1}, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: nil, + Dist: nil, + Repos: nil, + }, + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg2}, + Dist: nil, + Repos: []*claircore.Repository{repo2}, + }, + } + + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{pkg2.ID: pkg2}, + Distributions: map[string]*claircore.Distribution{}, + Repositories: map[string]*claircore.Repository{ + repo2.Name: repo2, + repo1.Name: repo1, + }, + Environments: map[string][]*claircore.Environment{ + pkg2.ID: { + { + PackageDB: pkg2.PackageDB, + RepositoryIDs: []string{repo2.Name}, + }, + }, + }, + } + + return input, want + }, }, { - Hash: test.RandomSHA256Digest(t), - Pkgs: []*claircore.Package{pkg2}, - Dist: nil, - Repos: []*claircore.Repository{repo2}, + Name: "WithDNF", + Fixture: func(t testing.TB) ([]*indexer.LayerArtifacts, *claircore.IndexReport) { + repo1 := &claircore.Repository{ + ID: "1", + Name: "test_1", + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::appstream"), + Key: repositoryKey, + } + pkg1 := &claircore.Package{ + ID: "1", + Name: "hello", + Version: "1.0-1", + PackageDB: "fixture:/var/lib/rpm", + RepositoryHint: (url.Values{ + "repoid": {repo1.Name}, + }).Encode(), + } + input := []*indexer.LayerArtifacts{ + { + Hash: test.RandomSHA256Digest(t), + Pkgs: []*claircore.Package{pkg1}, + Dist: nil, + Repos: []*claircore.Repository{repo1}, + }, + } + want := &claircore.IndexReport{ + Hash: test.RandomSHA256Digest(t), + Packages: map[string]*claircore.Package{pkg1.ID: pkg1}, + Distributions: map[string]*claircore.Distribution{}, + Repositories: map[string]*claircore.Repository{repo1.Name: repo1}, + Environments: map[string][]*claircore.Environment{ + pkg1.ID: { + { + PackageDB: pkg1.PackageDB, + RepositoryIDs: []string{repo1.Name}, + }, + }, + }, + } + return input, want + }, }, } - ir, err := coalescer.Coalesce(ctx, layerArtifacts) - if err != nil { - t.Fatalf("received error from coalesce method: %v", err) - } - if _, ok := ir.Packages[pkg1.ID]; ok { - t.Fatalf("Package %v was removed, but it is still available", pkg1) - } - if _, ok := ir.Environments[pkg1.ID]; ok { - t.Fatalf("Package %v was removed, but it is still available in environment", pkg1) + + for _, tc := range tcs { + tc.Run(ctx, t) } } diff --git a/rhel/distributionscanner_test.go b/rhel/distributionscanner_test.go index 6800a2de0..7e47e31f8 100644 --- a/rhel/distributionscanner_test.go +++ b/rhel/distributionscanner_test.go @@ -9,6 +9,7 @@ import ( ) func TestDistributionScanner(t *testing.T) { + t.Parallel() sys := os.DirFS(`testdata/releasefiles`) ents, err := fs.ReadDir(sys, ".") if err != nil { diff --git a/rhel/ecosystem.go b/rhel/ecosystem.go index ed5ac2523..be315ba3e 100644 --- a/rhel/ecosystem.go +++ b/rhel/ecosystem.go @@ -4,14 +4,13 @@ import ( "context" "github.com/quay/claircore/indexer" - "github.com/quay/claircore/rpm" ) // NewEcosystem provides the set of scanners and coalescer for the rhel ecosystem. func NewEcosystem(_ context.Context) *indexer.Ecosystem { return &indexer.Ecosystem{ PackageScanners: func(_ context.Context) ([]indexer.PackageScanner, error) { - return []indexer.PackageScanner{new(rpm.Scanner)}, nil + return []indexer.PackageScanner{PackageScanner{}}, nil }, DistributionScanners: func(_ context.Context) ([]indexer.DistributionScanner, error) { return []indexer.DistributionScanner{new(DistributionScanner)}, nil diff --git a/rhel/internal/containerapi/containerapi.go b/rhel/internal/containerapi/containerapi.go index db566bdc4..0bc9e5d1a 100644 --- a/rhel/internal/containerapi/containerapi.go +++ b/rhel/internal/containerapi/containerapi.go @@ -1,4 +1,7 @@ // Package containerapi is a minimal client around the Red Hat Container API. +// +// Deprecated: This package's functionality should only be required for +// container images that are long-since out of support. package containerapi import ( @@ -10,6 +13,7 @@ import ( "net/url" "path" "strings" + "sync" "github.com/quay/zlog" ) @@ -38,6 +42,13 @@ type ContainerAPI struct { // GetCPEs fetches CPE information for given build from Red Hat Container API. func (c *ContainerAPI) GetCPEs(ctx context.Context, nvr, arch string) ([]string, error) { + deprecationWarning.Do(func() { + zlog.Warn(ctx). + Bool("deprecation", true). + Msg("support for the Red Hat Container API will be removed in a future release") + zlog.Warn(ctx). + Msg("container images using this code are extremely old!") + }) uri, err := c.Root.Parse(path.Join("v1/images/nvr/", nvr)) if err != nil { return nil, err @@ -80,3 +91,5 @@ func (c *ContainerAPI) GetCPEs(ctx context.Context, nvr, arch string) ([]string, } return nil, nil } + +var deprecationWarning sync.Once diff --git a/rhel/matcher.go b/rhel/matcher.go index 8d1acbe51..af451f29f 100644 --- a/rhel/matcher.go +++ b/rhel/matcher.go @@ -12,24 +12,24 @@ import ( "github.com/quay/claircore/toolkit/types/cpe" ) -// Matcher implements driver.Matcher. +// Matcher implements [driver.Matcher]. type Matcher struct { ignoreUnpatched bool } var _ driver.Matcher = (*Matcher)(nil) -// Name implements driver.Matcher. +// Name implements [driver.Matcher]. func (*Matcher) Name() string { return "rhel" } -// Filter implements driver.Matcher. +// Filter implements [driver.Matcher]. func (*Matcher) Filter(record *claircore.IndexRecord) bool { return record.Repository != nil && record.Repository.Key == repositoryKey } -// Query implements driver.Matcher. +// Query implements [driver.Matcher]. func (m *Matcher) Query() []driver.MatchConstraint { mcs := []driver.MatchConstraint{driver.PackageModule, driver.RepositoryKey} if m.ignoreUnpatched { @@ -38,34 +38,37 @@ func (m *Matcher) Query() []driver.MatchConstraint { return mcs } -// IsCPESubstringMatch is a Red Hat specific hack that handles the "CPE patterns" in the VEX -// data. For historical/unfathomable reasons, Red Hat -// doesn't use the syntax defined in the Matching Expression spec. -// For example, "cpe:/a:redhat:openshift:4" is expected to match "cpe:/a:redhat:openshift:4.13::el8". +// IsCPESubstringMatch is a Red Hat specific hack that handles the "CPE +// patterns" in the VEX data. For historical/unfathomable reasons, Red Hat +// doesn't use the syntax defined in the Matching Expression spec. For example, +// "cpe:/a:redhat:openshift:4" is expected to match +// "cpe:/a:redhat:openshift:4.13::el8". // -// This is defined (citation needed) to be a substring match on the "pattern" and "target" CPEs. -// Since we always normalize CPEs into v2.3 "Formatted String" form, we need to trim the -// added "ANY" attributes from the pattern. +// This is defined (citation needed) to be a substring match on the "pattern" +// and "target" CPEs. Since we always normalize CPEs into v2.3 "Formatted +// String" form, we need to trim the added "ANY" attributes from the pattern. // -// TODO(crozzy) Remove once RH VEX data updates CPEs with standard matching expressions. +// TODO(crozzy) Remove once RH VEX data updates CPEs with standard matching +// expressions. func isCPESubstringMatch(recordCPE cpe.WFN, vulnCPE cpe.WFN) bool { return strings.HasPrefix(recordCPE.String(), strings.TrimRight(vulnCPE.String(), ":*")) } -// Vulnerable implements driver.Matcher. +// Vulnerable implements [driver.Matcher]. // -// Vulnerable will interpret the claircore.Vulnerability.Repo.CPE -// as a CPE match expression, and to be considered vulnerable, -// the relationship between claircore.IndexRecord.Repository.CPE and -// the claircore.Vulnerability.Repo.CPE needs to be a CPE Name Comparison -// Relation of SUPERSET(⊇)(Source is a superset or equal to the target). -// https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7696.pdf Section 6.2. +// Vulnerable will interpret the [claircore.Vulnerability].Repo.CPE as a CPE +// match expression, and to be considered vulnerable, the relationship between +// [claircore.IndexRecord].Repository.CPE and the +// [claircore.Vulnerability].Repo.CPE needs to be a CPE Name Comparison Relation +// of SUPERSET(⊇)(Source is a superset or equal to the target). +// +// See: https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7696.pdf Section 6.2. func (m *Matcher) Vulnerable(ctx context.Context, record *claircore.IndexRecord, vuln *claircore.Vulnerability) (bool, error) { if vuln.Repo == nil || record.Repository == nil || vuln.Repo.Key != repositoryKey { return false, nil } var err error - // This conversion has to be done because our current data structure doesn't + // This conversion has to be done because our current data model doesn't // support the claircore.Vulnerability.Repo.CPE field. vuln.Repo.CPE, err = cpe.Unbind(vuln.Repo.Name) if err != nil { @@ -79,6 +82,7 @@ func (m *Matcher) Vulnerable(ctx context.Context, record *claircore.IndexRecord, return false, nil } + // TODO(hank) Switch to the [rpmver] package. pkgVer := version.NewVersion(record.Package.Version) var vulnVer version.Version // Assume the vulnerability record we have is for the last known vulnerable diff --git a/rhel/matcher_test.go b/rhel/matcher_test.go index 26cd2eb32..14171774a 100644 --- a/rhel/matcher_test.go +++ b/rhel/matcher_test.go @@ -115,6 +115,8 @@ type vulnerableTestCase struct { } func TestVulnerable(t *testing.T) { + t.Parallel() + record := &claircore.IndexRecord{ Package: &claircore.Package{ Version: "0.33.0-6.el8", @@ -272,13 +274,13 @@ func TestIsCPEStringSubsetMatch(t *testing.T) { match bool }{ { - name: "simple_case", + name: "Simple", recordCPE: cpe.MustUnbind("cpe:/a:redhat:openshift:4.13::el8"), vulnCPE: cpe.MustUnbind("cpe:/a:redhat:openshift:4"), match: true, }, { - name: "wrong_minor", + name: "WrongMinor", recordCPE: cpe.MustUnbind("cpe:/a:redhat:openshift:4.13::el8"), vulnCPE: cpe.MustUnbind("cpe:/a:redhat:openshift:4.1::el8"), match: false, diff --git a/rhel/packagescanner.go b/rhel/packagescanner.go new file mode 100644 index 000000000..2a5ea1e33 --- /dev/null +++ b/rhel/packagescanner.go @@ -0,0 +1,91 @@ +package rhel + +import ( + "context" + "errors" + "fmt" + "io/fs" + "runtime/trace" + + "github.com/quay/zlog" + + "github.com/quay/claircore" + "github.com/quay/claircore/indexer" + "github.com/quay/claircore/internal/dnf" + "github.com/quay/claircore/internal/rpm" +) + +var _ indexer.PackageScanner = PackageScanner{} + +// PackageScanner implements a [indexer.PackageScanner] that consults both the +// rpm and dnf databases. +type PackageScanner struct{} + +// Kind implements [indexer.PackageScanner]. +func (p PackageScanner) Kind() string { return "package" } + +// Name implements [indexer.PackageScanner]. +func (p PackageScanner) Name() string { return "rhel-package-scanner" } + +// Version implements [indexer.PackageScanner]. +func (p PackageScanner) Version() string { return "1" } + +// Scan implements [indexer.PackageScanner]. +// +// This implementation stores additional information needed to correlate with +// [claircore.Repository] values in the "RepositoryHint" field. +func (p PackageScanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*claircore.Package, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + defer trace.StartRegion(ctx, "PackageScanner.Scan").End() + trace.Log(ctx, "layer", layer.Hash.String()) + ctx = zlog.ContextWithValues(ctx, + "component", "rhel/PackageScanner.Scan", + "version", p.Version(), + "layer", layer.Hash.String()) + zlog.Debug(ctx).Msg("start") + defer zlog.Debug(ctx).Msg("done") + + sys, err := layer.FS() + if err != nil { + return nil, fmt.Errorf("rhel: unable to open layer: %w", err) + } + + var out []*claircore.Package + found, errFunc := rpm.FindDBs(ctx, sys) + defer func() { + err = errors.Join(err, errFunc()) + }() + for found := range found { + err = func() error { + ctx := zlog.ContextWithValues(ctx, "db", found.String()) + zlog.Debug(ctx).Msg("examining database") + db, err := rpm.OpenDB(ctx, sys, found) + switch { + case err == nil: + case errors.Is(err, fs.ErrNotExist): + return nil + default: + return err + } + defer db.Close() + pkgs, err := dnf.Wrap(ctx, sys, db.Packages(ctx)) + if err != nil { + return err + } + for pkg, err := range pkgs { + if err != nil { + return err + } + out = append(out, &pkg) + } + return nil + }() + if err != nil { + return nil, err + } + } + + return out, nil +} diff --git a/rhel/packagescanner_test.go b/rhel/packagescanner_test.go new file mode 100644 index 000000000..0662d937f --- /dev/null +++ b/rhel/packagescanner_test.go @@ -0,0 +1,48 @@ +package rhel + +import ( + "context" + "path/filepath" + "testing" + + "github.com/quay/zlog" + + "github.com/quay/claircore/test" + "github.com/quay/claircore/test/rpmtest" +) + +//go:generate -command fetch go run github.com/quay/claircore/test/cmd/fetch-container-rpm-manifest +//go:generate fetch -o testdata/package/ubi8_ubi.txtar ubi8/ubi +//go:generate fetch -o testdata/package/ubi9_ubi.txtar ubi9/ubi +//go:generate fetch -o testdata/package/ubi9_httpd-24.txtar ubi9/httpd-24 + +func TestPackageDetection(t *testing.T) { + t.Parallel() + ctx := zlog.Test(context.Background(), t) + ms, err := filepath.Glob("testdata/package/*.txtar") + if err != nil { + panic("programmer error") // static glob + } + + a := test.NewCachedArena(t) + t.Cleanup(func() { + if err := a.Close(ctx); err != nil { + t.Error(err) + } + }) + // BUG(hank) The repoid information seems to not currently exist in Pyxis. + // The tests here use a hard-coded allowlist. + repoAllow := map[string][]string{ + "registry.access.redhat.com/ubi9/httpd-24": {"RHEL-9.0.0-updates-20220503.2-AppStream", "RHEL-9.0.0-updates-20220503.2-BaseOS"}, + } + s := new(PackageScanner) + + for _, m := range ms { + ar, err := rpmtest.OpenArchive(ctx, m) + if err != nil { + t.Error(err) + continue + } + ar.Tests(ctx, a, repoAllow, s.Scan)(t) + } +} diff --git a/rhel/parse_test.go b/rhel/parse_test.go index 62a9e7465..e7aca3134 100644 --- a/rhel/parse_test.go +++ b/rhel/parse_test.go @@ -14,8 +14,9 @@ import ( ) func TestCVEDefFromUnpatched(t *testing.T) { + t.Parallel() ctx := context.Background() - var table = []struct { + table := []struct { name string fileName string configFunc driver.ConfigUnmarshaler @@ -23,15 +24,15 @@ func TestCVEDefFromUnpatched(t *testing.T) { ignoreUnpatched bool }{ { - name: "default path", + name: "DefaultPath", fileName: "testdata/rhel-8-rpm-unpatched.xml", - configFunc: func(_ interface{}) error { return nil }, + configFunc: func(_ any) error { return nil }, expectedVulnCount: 192, }, { - name: "ignore unpatched path", + name: "IgnoreUnpatchedPath", fileName: "testdata/rhel-8-rpm-unpatched.xml", - configFunc: func(c interface{}) error { return nil }, + configFunc: func(c any) error { return nil }, ignoreUnpatched: true, expectedVulnCount: 0, }, diff --git a/rhel/repositoryscanner.go b/rhel/repositoryscanner.go index d1f2f53f1..6e411c5a7 100644 --- a/rhel/repositoryscanner.go +++ b/rhel/repositoryscanner.go @@ -12,6 +12,7 @@ import ( "os" "path/filepath" "runtime/trace" + "slices" "strings" "time" @@ -19,6 +20,7 @@ import ( "github.com/quay/claircore" "github.com/quay/claircore/indexer" + "github.com/quay/claircore/internal/dnf" "github.com/quay/claircore/internal/zreader" "github.com/quay/claircore/rhel/dockerfile" "github.com/quay/claircore/rhel/internal/common" @@ -26,25 +28,25 @@ import ( "github.com/quay/claircore/toolkit/types/cpe" ) -/* -RepositoryScanner implements repository detection logic for RHEL. - -The RHEL detection logic needs outside information because the Red Hat build -system does not (and did not, in the past) store the relevant information in the -layer itself. In addition, dnf and yum do not persist provenance information -outside of a cache and rpm considers such information outside its baliwick. - -In the case of the RHEL ecosystem, "repository" is a bit of a misnomer, as -advisories are tracked on the Product level, and so Clair's "repository" data is -used instead to indicate a Product. This mismatch can lead to apparent -duplications in reporting. For example, if an advisory is marked as affecting -"cpe:/a:redhat:enterprise_linux:8" and -"cpe:/a:redhat:enterprise_linux:8::appstream", this results in two advisories -being recorded. (CPEs do not namespace the way this example may imply; that is -to say, the latter is not "contained in" or a "member of" the former.) If a -layer reports that it is both the "cpe:/a:redhat:enterprise_linux:8" and -"cpe:/a:redhat:enterprise_linux:8::appstream" layer, then both advisories match. -*/ +// RepositoryScanner implements repository detection logic for RHEL. +// +// The RHEL detection logic needs outside information because the Red Hat build +// system does not (and did not, in the past) store the relevant information in +// the layer itself. In addition, dnf and yum do not persist provenance +// information outside of a cache and rpm considers such information outside its +// baliwick. +// +// In the case of the RHEL ecosystem, "repository" is a bit of a misnomer, as +// advisories are tracked on the Product level, and so Clair's "repository" data +// is used instead to indicate a Product. This mismatch can lead to apparent +// duplication in reporting. For example, if an advisory is marked as affecting +// "cpe:/a:redhat:enterprise_linux:8" and +// "cpe:/a:redhat:enterprise_linux:8::appstream", this results in two advisories +// being recorded. (CPEs do not namespace the way this example may imply; that +// is to say, the latter is not "contained in" or a "member of" the former.) If +// a layer reports that it is both the "cpe:/a:redhat:enterprise_linux:8" and +// "cpe:/a:redhat:enterprise_linux:8::appstream" layer, then both advisories +// match. type RepositoryScanner struct { // These members are created after the Configure call. upd *common.Updater @@ -72,8 +74,6 @@ var ( // - If both the "URL" and "File" are provided, the file will be loaded // initially and then updated periodically from the URL. type RepositoryScannerConfig struct { - // DisableAPI disables the use of the API. - DisableAPI bool `json:"disable_api" yaml:"disable_api"` // API is the URL to talk to the Red Hat Container API. // // See [DefaultContainerAPI] and [containerapi.ContainerAPI]. @@ -91,6 +91,8 @@ type RepositoryScannerConfig struct { // // The default is 10 seconds. Timeout time.Duration `json:"timeout" yaml:"timeout"` + // DisableAPI disables the use of the API. + DisableAPI bool `json:"disable_api" yaml:"disable_api"` } const ( @@ -110,7 +112,7 @@ const ( func (*RepositoryScanner) Name() string { return "rhel-repository-scanner" } // Version implements [indexer.VersionedScanner]. -func (*RepositoryScanner) Version() string { return "1.2" } +func (*RepositoryScanner) Version() string { return "2" } // Kind implements [indexer.VersionedScanner]. func (*RepositoryScanner) Kind() string { return "repository" } @@ -180,7 +182,10 @@ func (r *RepositoryScanner) Configure(ctx context.Context, f indexer.ConfigDeser } // Scan implements [indexer.RepositoryScanner]. -func (r *RepositoryScanner) Scan(ctx context.Context, l *claircore.Layer) (repositories []*claircore.Repository, err error) { +// +// The two important pieces of information are the "repoid" and CPE, which are +// stored in the [claircore.Repository]'s "Name" and "CPE" fields, respectively. +func (r *RepositoryScanner) Scan(ctx context.Context, l *claircore.Layer) ([]*claircore.Repository, error) { defer trace.StartRegion(ctx, "Scanner.Scan").End() ctx = zlog.ContextWithValues(ctx, "component", "rhel/RepositoryScanner.Scan", @@ -204,31 +209,81 @@ func (r *RepositoryScanner) Scan(ctx context.Context, l *claircore.Layer) (repos if !ok || cm == nil { return []*claircore.Repository{}, fmt.Errorf("rhel: unable to create a mappingFile object") } - CPEs, err := mapContentSets(ctx, sys, cm) + + // First, look at DNF. + repoids, err := dnf.FindRepoids(ctx, sys) + switch { + case err != nil: // continue to error check and return + case len(repoids) == 0: + // If DNF yielded nothing, check for content-sets data. + repoids, err = repoidsFromContentSets(ctx, sys) + default: + } if err != nil { return []*claircore.Repository{}, err } - if CPEs == nil && r.apiFetcher != nil { - // Embedded content-sets are available only for new images. - // For old images, use fallback option and query Red Hat Container API. - ctx, done := context.WithTimeout(ctx, r.cfg.Timeout) - defer done() - CPEs, err = mapContainerAPI(ctx, sys, r.apiFetcher) + + pairs := func(yield func(string, string) bool) { + var found bool + for _, repoid := range repoids { + cpes, ok := cm.GetOne(ctx, repoid) + if !ok { + continue + } + found = true + for _, cpe := range cpes { + if !yield(repoid, cpe) { + return + } + } + } + if found { + return + } + + if r.apiFetcher != nil { + // Embedded content-sets are unavailable in very old images. + // For these, use fallback option and query Red Hat Container API. + ctx, done := context.WithTimeout(ctx, r.cfg.Timeout) + defer done() + + // !!! This ends up being a weird nonlocal return. !!! + var cpes []string + cpes, err = mapContainerAPI(ctx, sys, r.apiFetcher) + if err != nil { + zlog.Warn(ctx). + Err(err). + Msg("container API error") + return + } + for _, cpe := range cpes { + if !yield("", cpe) { + return + } + } + } + } + var repositories []*claircore.Repository + for repoid, cpeID := range pairs { + // TODO(hank) Remove these ContainerAPI hacks: + // Start ContainerAPI hacks if err != nil { return []*claircore.Repository{}, err } - } + if repoid == "" { + repoid = cpeID + } + // End ContainerAPI hacks - for _, cpeID := range CPEs { r := &claircore.Repository{ - Name: cpeID, + Name: repoid, Key: repositoryKey, } r.CPE, err = cpe.Unbind(cpeID) if err != nil { zlog.Warn(ctx). Err(err). - Str("url", `https://bugzilla.redhat.com/enter_bug.cgi?product=Container%20Factory`). + Str("url", bugURL(cpeID, err)). Str("cpeID", cpeID). Msg("invalid CPE, please report a bug upstream") continue @@ -236,17 +291,47 @@ func (r *RepositoryScanner) Scan(ctx context.Context, l *claircore.Layer) (repos repositories = append(repositories, r) } + slices.SortFunc(repositories, func(a, b *claircore.Repository) int { + if ord := strings.Compare(a.Name, b.Name); ord != 0 { + return ord + } + if ord := strings.Compare(a.CPE.BindFS(), b.CPE.BindFS()); ord != 0 { + return ord + } + return 0 + }) + repositories = slices.CompactFunc(repositories, func(a, b *claircore.Repository) bool { + return a.Name == b.Name && a.CPE.BindFS() == b.CPE.BindFS() + }) return repositories, nil } -// MapContentSets returns a slice of CPEs bound into strings, as discovered by -// examining information contained within the container. -func mapContentSets(ctx context.Context, sys fs.FS, cm *mappingFile) ([]string, error) { - // Get CPEs using embedded content-set files. - // The files are stored in /root/buildinfo/content_manifests/ and will need to - // be translated using mapping file provided by Red Hat's PST team. - // For RHCOS, the files are stored in /usr/share/buildinfo/. +// BugURL constructs a link directly to the Red Hat Jira instance. +func bugURL(id string, err error) string { + const desc = "A Clair instance noticed an invalid CPE:{code}%s{code}\nThe reported error was:{code}%v{code}" + v := url.Values{ + "pid": {"12330022"}, // ID for the Red Hat Jira "SECDATA" project. + "issuetype": {"1"}, + "summary": {"invalid CPE in Red Hat data"}, + "description": {fmt.Sprintf(desc, id, err)}, + } + u := url.URL{ + Scheme: "https", + Host: "issues.redhat.com", + Path: "/secure/CreateIssueDetails!init.jspa", + RawQuery: v.Encode(), + } + return u.String() +} + +// RepoidsFromContentSets returns a slice of repoids, as discovered by examining +// information contained within the container. +func repoidsFromContentSets(ctx context.Context, sys fs.FS) ([]string, error) { + // Get repoids using embedded content-set files. The files are stored in + // /root/buildinfo/content_manifests/ and will need to be translated using + // mapping file provided by Red Hat's PST team. For RHCOS, the files are + // stored in /usr/share/buildinfo/. ms, err := fs.Glob(sys, `root/buildinfo/content_manifests/*.json`) if err != nil { panic("programmer error: " + err.Error()) @@ -286,7 +371,7 @@ func mapContentSets(ctx context.Context, sys fs.FS, cm *mappingFile) ([]string, if len(m.ContentSets) == 0 { return nil, nil } - return cm.Get(ctx, m.ContentSets) + return m.ContentSets, nil } // MappingFile is a data struct for mapping file between repositories and CPEs @@ -299,27 +384,16 @@ type repo struct { CPEs []string `json:"cpes"` } -func (m *mappingFile) Get(ctx context.Context, rs []string) ([]string, error) { - s := map[string]struct{}{} - for _, r := range rs { - cpes, ok := m.Data[r] - if !ok { - zlog.Debug(ctx). - Str("repository", r). - Msg("repository not present in a mapping file") - continue - } - for _, cpe := range cpes.CPEs { - s[cpe] = struct{}{} - } +// GetOne takes a repoid and reports the CPEs and if the repoid was known +// beforehand. +func (m *mappingFile) GetOne(ctx context.Context, repoid string) (cpes []string, ok bool) { + if repo, ok := m.Data[repoid]; ok { + return repo.CPEs, true } - - i, r := 0, make([]string, len(s)) - for k := range s { - r[i] = k - i++ - } - return r, nil + zlog.Debug(ctx). + Str("repository", repoid). + Msg("repository not present in a mapping file") + return nil, false } // ContentManifest structure is the data provided by OSBS. diff --git a/rhel/repositoryscanner_test.go b/rhel/repositoryscanner_test.go index 389653ad9..be2d61d1a 100644 --- a/rhel/repositoryscanner_test.go +++ b/rhel/repositoryscanner_test.go @@ -103,17 +103,22 @@ func TestRepositoryScanner(t *testing.T) { name: "FromMappingUrl", want: []*claircore.Repository{ { - Name: "cpe:/o:redhat:enterprise_linux:6::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:6::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:7::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:8::server", + Name: "content-set-2", + Key: repositoryKey, + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), + }, + { + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::server"), }, @@ -125,17 +130,22 @@ func TestRepositoryScanner(t *testing.T) { name: "FromMappingFile", want: []*claircore.Repository{ { - Name: "cpe:/o:redhat:enterprise_linux:6::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:6::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:7::server", + Name: "content-set-1", + Key: repositoryKey, + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), + }, + { + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:8::server", + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::server"), }, @@ -147,17 +157,22 @@ func TestRepositoryScanner(t *testing.T) { name: "FromMappingFileAirGap", want: []*claircore.Repository{ { - Name: "cpe:/o:redhat:enterprise_linux:6::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:6::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:7::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:8::server", + Name: "content-set-2", + Key: repositoryKey, + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), + }, + { + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::server"), }, @@ -176,47 +191,60 @@ func TestRepositoryScanner(t *testing.T) { want: nil, cfg: &RepositoryScannerConfig{DisableAPI: true}, layerPath: "testdata/layer-with-embedded-cs.tar", - }, { + }, + { name: "BadContentManifestsFile", want: nil, cfg: &RepositoryScannerConfig{API: srv.URL, Repo2CPEMappingURL: srv.URL + "/repository-2-cpe.json"}, layerPath: "testdata/layer-with-invalid-content-manifests-json.tar", - }, { + }, + { name: "RHCOSLayerFromMappingFile", want: []*claircore.Repository{ { - Name: "cpe:/o:redhat:enterprise_linux:6::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:6::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:7::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:8::server", + Name: "content-set-2", + Key: repositoryKey, + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), + }, + { + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::server"), }, }, cfg: &RepositoryScannerConfig{Repo2CPEMappingFile: f.Name()}, layerPath: "testdata/rhcos-layer-with-embedded-cs.tar", - }, { + }, + { name: "RHCOSLayerFromMappingFileWithConflictingFiles", want: []*claircore.Repository{ { - Name: "cpe:/o:redhat:enterprise_linux:6::server", + Name: "content-set-1", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:6::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:7::server", + Name: "content-set-1", + Key: repositoryKey, + CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), + }, + { + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:7::server"), }, { - Name: "cpe:/o:redhat:enterprise_linux:8::server", + Name: "content-set-2", Key: repositoryKey, CPE: cpe.MustUnbind("cpe:/o:redhat:enterprise_linux:8::server"), }, @@ -287,3 +315,19 @@ func TestLabelError(t *testing.T) { t.Errorf("%v != %v", got, want) } } + +func TestBugURL(t *testing.T) { + const in = `cpe:/a:redhat:openshift:4.*` + const want = `https://issues.redhat.com/secure/CreateIssueDetails%21init.jspa?description=A+Clair+instance+noticed+an+invalid+CPE%3A%7Bcode%7Dcpe%3A%2Fa%3Aredhat%3Aopenshift%3A4.%2A%7Bcode%7D%0AThe+reported+error+was%3A%7Bcode%7Dcpe%3A+version%3A+disallowed+character+%27%2A%27%7Bcode%7D&issuetype=1&pid=12330022&summary=invalid+CPE+in+Red+Hat+data` + + _, err := cpe.Unbind(in) + if err == nil { + t.Error("expected error") + } + got := bugURL(in, err) + + t.Logf("\ngot: %s\nwant: %s", got, want) + if got != want { + t.Fail() + } +} diff --git a/rhel/testdata/bdb.rpm-manifest.json b/rhel/testdata/bdb.rpm-manifest.json new file mode 100644 index 000000000..649f00bd0 --- /dev/null +++ b/rhel/testdata/bdb.rpm-manifest.json @@ -0,0 +1,1571 @@ +{ + "object_type": "containerImageRPMManifest", + "rpms": [ + { + "srpm_name": "tzdata", + "name": "tzdata", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "tzdata-2019a-1.el8.src", + "release": "1.el8", + "nerva": "tzdata-2019a-1.el8.noarch" + }, + { + "srpm_name": "ncurses", + "name": "ncurses-base", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ncurses-6.1-7.20180224.el8.src", + "release": "7.20180224.el8", + "nerva": "ncurses-base-6.1-7.20180224.el8.noarch" + }, + { + "srpm_name": "dnf", + "name": "dnf-data", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dnf-4.0.9.2-5.el8.src", + "release": "5.el8", + "nerva": "dnf-data-4.0.9.2-5.el8.noarch" + }, + { + "srpm_name": "dbus", + "name": "dbus-common", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dbus-1.12.8-7.el8.src", + "release": "7.el8", + "nerva": "dbus-common-1:1.12.8-7.el8.noarch" + }, + { + "srpm_name": "setup", + "name": "setup", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "setup-2.12.2-1.el8.src", + "release": "1.el8", + "nerva": "setup-2.12.2-1.el8.noarch" + }, + { + "srpm_name": "basesystem", + "name": "basesystem", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "basesystem-11-5.el8.src", + "release": "5.el8", + "nerva": "basesystem-11-5.el8.noarch" + }, + { + "srpm_name": "libselinux", + "name": "libselinux", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libselinux-2.8-6.el8.src", + "release": "6.el8", + "nerva": "libselinux-2.8-6.el8.x86_64" + }, + { + "srpm_name": "glibc", + "name": "glibc-minimal-langpack", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "glibc-2.28-42.el8.1.src", + "release": "42.el8.1", + "nerva": "glibc-minimal-langpack-2.28-42.el8.1.x86_64" + }, + { + "srpm_name": "glibc", + "name": "glibc", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "glibc-2.28-42.el8.1.src", + "release": "42.el8.1", + "nerva": "glibc-2.28-42.el8.1.x86_64" + }, + { + "srpm_name": "libsepol", + "name": "libsepol", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libsepol-2.8-2.el8.src", + "release": "2.el8", + "nerva": "libsepol-2.8-2.el8.x86_64" + }, + { + "srpm_name": "xz", + "name": "xz-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "xz-5.2.4-3.el8.src", + "release": "3.el8", + "nerva": "xz-libs-5.2.4-3.el8.x86_64" + }, + { + "srpm_name": "libcap", + "name": "libcap", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libcap-2.25-9.el8.src", + "release": "9.el8", + "nerva": "libcap-2.25-9.el8.x86_64" + }, + { + "srpm_name": "libgpg-error", + "name": "libgpg-error", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libgpg-error-1.31-1.el8.src", + "release": "1.el8", + "nerva": "libgpg-error-1.31-1.el8.x86_64" + }, + { + "srpm_name": "e2fsprogs", + "name": "libcom_err", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "e2fsprogs-1.44.3-2.el8.src", + "release": "2.el8", + "nerva": "libcom_err-1.44.3-2.el8.x86_64" + }, + { + "srpm_name": "libxml2", + "name": "libxml2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libxml2-2.9.7-5.el8.src", + "release": "5.el8", + "nerva": "libxml2-2.9.7-5.el8.x86_64" + }, + { + "srpm_name": "expat", + "name": "expat", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "expat-2.2.5-3.el8.src", + "release": "3.el8", + "nerva": "expat-2.2.5-3.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "libuuid", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "libuuid-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "chkconfig", + "name": "chkconfig", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "chkconfig-1.11-1.el8.src", + "release": "1.el8", + "nerva": "chkconfig-1.11-1.el8.x86_64" + }, + { + "srpm_name": "gmp", + "name": "gmp", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gmp-6.1.2-8.el8.src", + "release": "8.el8", + "nerva": "gmp-1:6.1.2-8.el8.x86_64" + }, + { + "srpm_name": "attr", + "name": "libattr", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "attr-2.4.48-3.el8.src", + "release": "3.el8", + "nerva": "libattr-2.4.48-3.el8.x86_64" + }, + { + "srpm_name": "coreutils", + "name": "coreutils-single", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "coreutils-8.30-6.el8.src", + "release": "6.el8", + "nerva": "coreutils-single-8.30-6.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "libblkid", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "libblkid-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "libcap-ng", + "name": "libcap-ng", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libcap-ng-0.7.9-4.el8.src", + "release": "4.el8", + "nerva": "libcap-ng-0.7.9-4.el8.x86_64" + }, + { + "srpm_name": "libffi", + "name": "libffi", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libffi-3.1-18.el8.src", + "release": "18.el8", + "nerva": "libffi-3.1-18.el8.x86_64" + }, + { + "srpm_name": "lua", + "name": "lua-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "lua-5.3.4-10.el8.src", + "release": "10.el8", + "nerva": "lua-libs-5.3.4-10.el8.x86_64" + }, + { + "srpm_name": "p11-kit", + "name": "p11-kit", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "p11-kit-0.23.14-4.el8.src", + "release": "4.el8", + "nerva": "p11-kit-0.23.14-4.el8.x86_64" + }, + { + "srpm_name": "gzip", + "name": "gzip", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gzip-1.9-4.el8.src", + "release": "4.el8", + "nerva": "gzip-1.9-4.el8.x86_64" + }, + { + "srpm_name": "libassuan", + "name": "libassuan", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libassuan-2.5.1-3.el8.src", + "release": "3.el8", + "nerva": "libassuan-2.5.1-3.el8.x86_64" + }, + { + "srpm_name": "libidn2", + "name": "libidn2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libidn2-2.0.5-1.el8.src", + "release": "1.el8", + "nerva": "libidn2-2.0.5-1.el8.x86_64" + }, + { + "srpm_name": "gdbm", + "name": "gdbm-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gdbm-1.18-1.el8.src", + "release": "1.el8", + "nerva": "gdbm-libs-1:1.18-1.el8.x86_64" + }, + { + "srpm_name": "libtasn1", + "name": "libtasn1", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libtasn1-4.13-3.el8.src", + "release": "3.el8", + "nerva": "libtasn1-4.13-3.el8.x86_64" + }, + { + "srpm_name": "lzo", + "name": "lzo", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "lzo-2.08-14.el8.src", + "release": "14.el8", + "nerva": "lzo-2.08-14.el8.x86_64" + }, + { + "srpm_name": "grep", + "name": "grep", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "grep-3.1-6.el8.src", + "release": "6.el8", + "nerva": "grep-3.1-6.el8.x86_64" + }, + { + "srpm_name": "glib2", + "name": "glib2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "glib2-2.56.4-1.el8.src", + "release": "1.el8", + "nerva": "glib2-2.56.4-1.el8.x86_64" + }, + { + "srpm_name": "dbus", + "name": "dbus-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dbus-1.12.8-7.el8.src", + "release": "7.el8", + "nerva": "dbus-libs-1:1.12.8-7.el8.x86_64" + }, + { + "srpm_name": "openssl", + "name": "openssl-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "openssl-1.1.1-8.el8.src", + "release": "8.el8", + "nerva": "openssl-libs-1:1.1.1-8.el8.x86_64" + }, + { + "srpm_name": "kmod", + "name": "kmod-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "kmod-25-11.el8.src", + "release": "11.el8", + "nerva": "kmod-libs-25-11.el8.x86_64" + }, + { + "srpm_name": "kmod", + "name": "kmod", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "kmod-25-11.el8.src", + "release": "11.el8", + "nerva": "kmod-25-11.el8.x86_64" + }, + { + "srpm_name": "libarchive", + "name": "libarchive", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libarchive-3.3.2-3.el8.src", + "release": "3.el8", + "nerva": "libarchive-3.3.2-3.el8.x86_64" + }, + { + "srpm_name": "dhcp", + "name": "dhcp-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dhcp-4.3.6-30.el8.src", + "release": "30.el8", + "nerva": "dhcp-libs-12:4.3.6-30.el8.x86_64" + }, + { + "srpm_name": "procps-ng", + "name": "procps-ng", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "procps-ng-3.3.15-1.el8.src", + "release": "1.el8", + "nerva": "procps-ng-3.3.15-1.el8.x86_64" + }, + { + "srpm_name": "squashfs-tools", + "name": "squashfs-tools", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "squashfs-tools-4.3-17.el8.src", + "release": "17.el8", + "nerva": "squashfs-tools-4.3-17.el8.x86_64" + }, + { + "srpm_name": "libsemanage", + "name": "libsemanage", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libsemanage-2.8-5.el8.src", + "release": "5.el8", + "nerva": "libsemanage-2.8-5.el8.x86_64" + }, + { + "srpm_name": "dbus", + "name": "dbus-daemon", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dbus-1.12.8-7.el8.src", + "release": "7.el8", + "nerva": "dbus-daemon-1:1.12.8-7.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "libfdisk", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "libfdisk-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "mpfr", + "name": "mpfr", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "mpfr-3.1.6-1.el8.src", + "release": "1.el8", + "nerva": "mpfr-3.1.6-1.el8.x86_64" + }, + { + "srpm_name": "gnutls", + "name": "gnutls", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gnutls-3.6.5-2.el8.src", + "release": "2.el8", + "nerva": "gnutls-3.6.5-2.el8.x86_64" + }, + { + "srpm_name": "libcomps", + "name": "libcomps", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libcomps-0.1.8-13.el8.src", + "release": "13.el8", + "nerva": "libcomps-0.1.8-13.el8.x86_64" + }, + { + "srpm_name": "libksba", + "name": "libksba", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libksba-1.3.5-7.el8.src", + "release": "7.el8", + "nerva": "libksba-1.3.5-7.el8.x86_64" + }, + { + "srpm_name": "cpio", + "name": "cpio", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "cpio-2.12-8.el8.src", + "release": "8.el8", + "nerva": "cpio-2.12-8.el8.x86_64" + }, + { + "srpm_name": "ipcalc", + "name": "ipcalc", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ipcalc-0.2.4-3.el8.src", + "release": "3.el8", + "nerva": "ipcalc-0.2.4-3.el8.x86_64" + }, + { + "srpm_name": "iproute", + "name": "iproute", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "iproute-4.18.0-11.el8.src", + "release": "11.el8", + "nerva": "iproute-4.18.0-11.el8.x86_64" + }, + { + "srpm_name": "pkgconf", + "name": "libpkgconf", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pkgconf-1.4.2-1.el8.src", + "release": "1.el8", + "nerva": "libpkgconf-1.4.2-1.el8.x86_64" + }, + { + "srpm_name": "pkgconf", + "name": "pkgconf-pkg-config", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pkgconf-1.4.2-1.el8.src", + "release": "1.el8", + "nerva": "pkgconf-pkg-config-1.4.2-1.el8.x86_64" + }, + { + "srpm_name": "iptables", + "name": "iptables-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "iptables-1.8.2-9.el8.src", + "release": "9.el8", + "nerva": "iptables-libs-1.8.2-9.el8.x86_64" + }, + { + "srpm_name": "libsigsegv", + "name": "libsigsegv", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libsigsegv-2.11-5.el8.src", + "release": "5.el8", + "nerva": "libsigsegv-2.11-5.el8.x86_64" + }, + { + "srpm_name": "libverto", + "name": "libverto", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libverto-0.3.0-5.el8.src", + "release": "5.el8", + "nerva": "libverto-0.3.0-5.el8.x86_64" + }, + { + "srpm_name": "libtirpc", + "name": "libtirpc", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libtirpc-1.1.4-3.el8.src", + "release": "3.el8", + "nerva": "libtirpc-1.1.4-3.el8.x86_64" + }, + { + "srpm_name": "python-pip", + "name": "platform-python-pip", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python-pip-9.0.3-13.el8.src", + "release": "13.el8", + "nerva": "platform-python-pip-9.0.3-13.el8.noarch" + }, + { + "srpm_name": "python3", + "name": "platform-python", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python3-3.6.8-1.el8.0.1.src", + "release": "1.el8.0.1", + "nerva": "platform-python-3.6.8-1.el8.0.1.x86_64" + }, + { + "srpm_name": "libpwquality", + "name": "libpwquality", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libpwquality-1.4.0-9.el8.src", + "release": "9.el8", + "nerva": "libpwquality-1.4.0-9.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "util-linux", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "util-linux-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "curl", + "name": "curl", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "curl-7.61.1-8.el8.src", + "release": "8.el8", + "nerva": "curl-7.61.1-8.el8.x86_64" + }, + { + "srpm_name": "rpm", + "name": "rpm-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "rpm-4.14.2-9.el8.src", + "release": "9.el8", + "nerva": "rpm-libs-4.14.2-9.el8.x86_64" + }, + { + "srpm_name": "lvm2", + "name": "device-mapper", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "lvm2-2.03.02-6.el8.src", + "release": "6.el8", + "nerva": "device-mapper-8:1.02.155-6.el8.x86_64" + }, + { + "srpm_name": "cryptsetup", + "name": "cryptsetup-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "cryptsetup-2.0.6-1.el8.src", + "release": "1.el8", + "nerva": "cryptsetup-libs-2.0.6-1.el8.x86_64" + }, + { + "srpm_name": "elfutils", + "name": "elfutils-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "elfutils-0.174-6.el8.src", + "release": "6.el8", + "nerva": "elfutils-libs-0.174-6.el8.x86_64" + }, + { + "srpm_name": "systemd", + "name": "systemd", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "systemd-239-13.el8.src", + "release": "13.el8", + "nerva": "systemd-239-13.el8.x86_64" + }, + { + "srpm_name": "iputils", + "name": "iputils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "iputils-20180629-1.el8.src", + "release": "1.el8", + "nerva": "iputils-20180629-1.el8.x86_64" + }, + { + "srpm_name": "libkcapi", + "name": "libkcapi-hmaccalc", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libkcapi-1.1.1-16_1.el8.src", + "release": "16_1.el8", + "nerva": "libkcapi-hmaccalc-1.1.1-16_1.el8.x86_64" + }, + { + "srpm_name": "dracut", + "name": "dracut", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dracut-049-10.git20190115.el8.src", + "release": "10.git20190115.el8", + "nerva": "dracut-049-10.git20190115.el8.x86_64" + }, + { + "srpm_name": "libcomps", + "name": "python3-libcomps", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libcomps-0.1.8-13.el8.src", + "release": "13.el8", + "nerva": "python3-libcomps-0.1.8-13.el8.x86_64" + }, + { + "srpm_name": "python-iniparse", + "name": "python3-iniparse", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python-iniparse-0.4-31.el8.src", + "release": "31.el8", + "nerva": "python3-iniparse-0.4-31.el8.noarch" + }, + { + "srpm_name": "dhcp", + "name": "dhcp-client", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dhcp-4.3.6-30.el8.src", + "release": "30.el8", + "nerva": "dhcp-client-12:4.3.6-30.el8.x86_64" + }, + { + "srpm_name": "cyrus-sasl", + "name": "cyrus-sasl-lib", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "cyrus-sasl-2.1.27-0.3rc7.el8.src", + "release": "0.3rc7.el8", + "nerva": "cyrus-sasl-lib-2.1.27-0.3rc7.el8.x86_64" + }, + { + "srpm_name": "libyaml", + "name": "libyaml", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libyaml-0.1.7-5.el8.src", + "release": "5.el8", + "nerva": "libyaml-0.1.7-5.el8.x86_64" + }, + { + "srpm_name": "npth", + "name": "npth", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "npth-1.5-4.el8.src", + "release": "4.el8", + "nerva": "npth-1.5-4.el8.x86_64" + }, + { + "srpm_name": "gpgme", + "name": "gpgme", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gpgme-1.10.0-6.el8.0.1.src", + "release": "6.el8.0.1", + "nerva": "gpgme-1.10.0-6.el8.0.1.x86_64" + }, + { + "srpm_name": "libdnf", + "name": "libdnf", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libdnf-0.22.5-4.el8.src", + "release": "4.el8", + "nerva": "libdnf-0.22.5-4.el8.x86_64" + }, + { + "srpm_name": "libdnf", + "name": "python3-hawkey", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libdnf-0.22.5-4.el8.src", + "release": "4.el8", + "nerva": "python3-hawkey-0.22.5-4.el8.x86_64" + }, + { + "srpm_name": "rpm", + "name": "rpm-build-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "rpm-4.14.2-9.el8.src", + "release": "9.el8", + "nerva": "rpm-build-libs-4.14.2-9.el8.x86_64" + }, + { + "srpm_name": "dnf", + "name": "python3-dnf", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dnf-4.0.9.2-5.el8.src", + "release": "5.el8", + "nerva": "python3-dnf-4.0.9.2-5.el8.noarch" + }, + { + "srpm_name": "dnf", + "name": "yum", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dnf-4.0.9.2-5.el8.src", + "release": "5.el8", + "nerva": "yum-4.0.9.2-5.el8.noarch" + }, + { + "srpm_name": "binutils", + "name": "binutils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "binutils-2.30-49.el8.src", + "release": "49.el8", + "nerva": "binutils-2.30-49.el8.x86_64" + }, + { + "srpm_name": "vim", + "name": "vim-minimal", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "vim-8.0.1763-10.el8.src", + "release": "10.el8", + "nerva": "vim-minimal-2:8.0.1763-10.el8.x86_64" + }, + { + "srpm_name": "less", + "name": "less", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "less-530-1.el8.src", + "release": "1.el8", + "nerva": "less-530-1.el8.x86_64" + }, + { + "srpm_name": "rootfiles", + "name": "rootfiles", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "rootfiles-8.1-22.el8.src", + "release": "22.el8", + "nerva": "rootfiles-8.1-22.el8.noarch" + }, + { + "srpm_name": "gcc", + "name": "libgcc", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gcc-8.2.1-3.5.el8.src", + "release": "3.5.el8", + "nerva": "libgcc-8.2.1-3.5.el8.x86_64" + }, + { + "srpm_name": "pkgconf", + "name": "pkgconf-m4", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pkgconf-1.4.2-1.el8.src", + "release": "1.el8", + "nerva": "pkgconf-m4-1.4.2-1.el8.noarch" + }, + { + "srpm_name": "libreport", + "name": "libreport-filesystem", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libreport-2.9.5-6.el8.src", + "release": "6.el8", + "nerva": "libreport-filesystem-2.9.5-6.el8.x86_64" + }, + { + "srpm_name": "dhcp", + "name": "dhcp-common", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dhcp-4.3.6-30.el8.src", + "release": "30.el8", + "nerva": "dhcp-common-12:4.3.6-30.el8.noarch" + }, + { + "srpm_name": "centos-release", + "name": "centos-release", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "centos-release-8.0-0.1905.0.9.el8.src", + "release": "0.1905.0.9.el8", + "nerva": "centos-release-8.0-0.1905.0.9.el8.x86_64" + }, + { + "srpm_name": "filesystem", + "name": "filesystem", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "filesystem-3.8-2.el8.src", + "release": "2.el8", + "nerva": "filesystem-3.8-2.el8.x86_64" + }, + { + "srpm_name": "pcre2", + "name": "pcre2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pcre2-10.32-1.el8.src", + "release": "1.el8", + "nerva": "pcre2-10.32-1.el8.x86_64" + }, + { + "srpm_name": "ncurses", + "name": "ncurses-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ncurses-6.1-7.20180224.el8.src", + "release": "7.20180224.el8", + "nerva": "ncurses-libs-6.1-7.20180224.el8.x86_64" + }, + { + "srpm_name": "glibc", + "name": "glibc-common", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "glibc-2.28-42.el8.1.src", + "release": "42.el8.1", + "nerva": "glibc-common-2.28-42.el8.1.x86_64" + }, + { + "srpm_name": "bash", + "name": "bash", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "bash-4.4.19-7.el8.src", + "release": "7.el8", + "nerva": "bash-4.4.19-7.el8.x86_64" + }, + { + "srpm_name": "zlib", + "name": "zlib", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "zlib-1.2.11-10.el8.src", + "release": "10.el8", + "nerva": "zlib-1.2.11-10.el8.x86_64" + }, + { + "srpm_name": "bzip2", + "name": "bzip2-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "bzip2-1.0.6-26.el8.src", + "release": "26.el8", + "nerva": "bzip2-libs-1.0.6-26.el8.x86_64" + }, + { + "srpm_name": "texinfo", + "name": "info", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "texinfo-6.5-4.el8.src", + "release": "4.el8", + "nerva": "info-6.5-4.el8.x86_64" + }, + { + "srpm_name": "elfutils", + "name": "elfutils-libelf", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "elfutils-0.174-6.el8.src", + "release": "6.el8", + "nerva": "elfutils-libelf-0.174-6.el8.x86_64" + }, + { + "srpm_name": "libxcrypt", + "name": "libxcrypt", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libxcrypt-4.1.1-4.el8.src", + "release": "4.el8", + "nerva": "libxcrypt-4.1.1-4.el8.x86_64" + }, + { + "srpm_name": "sqlite", + "name": "sqlite-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "sqlite-3.26.0-3.el8.src", + "release": "3.el8", + "nerva": "sqlite-libs-3.26.0-3.el8.x86_64" + }, + { + "srpm_name": "gcc", + "name": "libstdc++", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gcc-8.2.1-3.5.el8.src", + "release": "3.5.el8", + "nerva": "libstdc++-8.2.1-3.5.el8.x86_64" + }, + { + "srpm_name": "popt", + "name": "popt", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "popt-1.16-14.el8.src", + "release": "14.el8", + "nerva": "popt-1.16-14.el8.x86_64" + }, + { + "srpm_name": "readline", + "name": "readline", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "readline-7.0-10.el8.src", + "release": "10.el8", + "nerva": "readline-7.0-10.el8.x86_64" + }, + { + "srpm_name": "json-c", + "name": "json-c", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "json-c-0.13.1-0.2.el8.src", + "release": "0.2.el8", + "nerva": "json-c-0.13.1-0.2.el8.x86_64" + }, + { + "srpm_name": "acl", + "name": "libacl", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "acl-2.2.53-1.el8.src", + "release": "1.el8", + "nerva": "libacl-2.2.53-1.el8.x86_64" + }, + { + "srpm_name": "sed", + "name": "sed", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "sed-4.5-1.el8.src", + "release": "1.el8", + "nerva": "sed-4.5-1.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "libmount", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "libmount-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "audit", + "name": "audit-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "audit-3.0-0.10.20180831git0047a6c.el8.src", + "release": "0.10.20180831git0047a6c.el8", + "nerva": "audit-libs-3.0-0.10.20180831git0047a6c.el8.x86_64" + }, + { + "srpm_name": "util-linux", + "name": "libsmartcols", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "util-linux-2.32.1-8.el8.src", + "release": "8.el8", + "nerva": "libsmartcols-2.32.1-8.el8.x86_64" + }, + { + "srpm_name": "lz4", + "name": "lz4-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "lz4-1.8.1.2-4.el8.src", + "release": "4.el8", + "nerva": "lz4-libs-1.8.1.2-4.el8.x86_64" + }, + { + "srpm_name": "libgcrypt", + "name": "libgcrypt", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libgcrypt-1.8.3-2.el8.src", + "release": "2.el8", + "nerva": "libgcrypt-1.8.3-2.el8.x86_64" + }, + { + "srpm_name": "cracklib", + "name": "cracklib", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "cracklib-2.9.6-15.el8.src", + "release": "15.el8", + "nerva": "cracklib-2.9.6-15.el8.x86_64" + }, + { + "srpm_name": "libunistring", + "name": "libunistring", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libunistring-0.9.9-3.el8.src", + "release": "3.el8", + "nerva": "libunistring-0.9.9-3.el8.x86_64" + }, + { + "srpm_name": "file", + "name": "file-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "file-5.33-8.el8.src", + "release": "8.el8", + "nerva": "file-libs-5.33-8.el8.x86_64" + }, + { + "srpm_name": "keyutils", + "name": "keyutils-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "keyutils-1.5.10-6.el8.src", + "release": "6.el8", + "nerva": "keyutils-libs-1.5.10-6.el8.x86_64" + }, + { + "srpm_name": "p11-kit", + "name": "p11-kit-trust", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "p11-kit-0.23.14-4.el8.src", + "release": "4.el8", + "nerva": "p11-kit-trust-0.23.14-4.el8.x86_64" + }, + { + "srpm_name": "pcre", + "name": "pcre", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pcre-8.42-4.el8.src", + "release": "4.el8", + "nerva": "pcre-8.42-4.el8.x86_64" + }, + { + "srpm_name": "systemd", + "name": "systemd-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "systemd-239-13.el8.src", + "release": "13.el8", + "nerva": "systemd-libs-239-13.el8.x86_64" + }, + { + "srpm_name": "crypto-policies", + "name": "crypto-policies", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "crypto-policies-20181217-6.git9a35207.el8.src", + "release": "6.git9a35207.el8", + "nerva": "crypto-policies-20181217-6.git9a35207.el8.noarch" + }, + { + "srpm_name": "ca-certificates", + "name": "ca-certificates", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ca-certificates-2018.2.24-6.el8.src", + "release": "6.el8", + "nerva": "ca-certificates-2018.2.24-6.el8.noarch" + }, + { + "srpm_name": "libdb", + "name": "libdb", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libdb-5.3.28-36.el8.src", + "release": "36.el8", + "nerva": "libdb-5.3.28-36.el8.x86_64" + }, + { + "srpm_name": "ima-evm-utils", + "name": "ima-evm-utils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ima-evm-utils-1.1-4.el8.src", + "release": "4.el8", + "nerva": "ima-evm-utils-1.1-4.el8.x86_64" + }, + { + "srpm_name": "libdb", + "name": "libdb-utils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libdb-5.3.28-36.el8.src", + "release": "36.el8", + "nerva": "libdb-utils-5.3.28-36.el8.x86_64" + }, + { + "srpm_name": "dbus", + "name": "dbus-tools", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dbus-1.12.8-7.el8.src", + "release": "7.el8", + "nerva": "dbus-tools-1:1.12.8-7.el8.x86_64" + }, + { + "srpm_name": "libusbx", + "name": "libusbx", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libusbx-1.0.22-1.el8.src", + "release": "1.el8", + "nerva": "libusbx-1.0.22-1.el8.x86_64" + }, + { + "srpm_name": "xz", + "name": "xz", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "xz-5.2.4-3.el8.src", + "release": "3.el8", + "nerva": "xz-5.2.4-3.el8.x86_64" + }, + { + "srpm_name": "gdbm", + "name": "gdbm", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gdbm-1.18-1.el8.src", + "release": "1.el8", + "nerva": "gdbm-1:1.18-1.el8.x86_64" + }, + { + "srpm_name": "shadow-utils", + "name": "shadow-utils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "shadow-utils-4.6-7.el8.src", + "release": "7.el8", + "nerva": "shadow-utils-2:4.6-7.el8.x86_64" + }, + { + "srpm_name": "libutempter", + "name": "libutempter", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libutempter-1.1.6-14.el8.src", + "release": "14.el8", + "nerva": "libutempter-1.1.6-14.el8.x86_64" + }, + { + "srpm_name": "acl", + "name": "acl", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "acl-2.2.53-1.el8.src", + "release": "1.el8", + "nerva": "acl-2.2.53-1.el8.x86_64" + }, + { + "srpm_name": "nettle", + "name": "nettle", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "nettle-3.4.1-1.el8.src", + "release": "1.el8", + "nerva": "nettle-3.4.1-1.el8.x86_64" + }, + { + "srpm_name": "snappy", + "name": "snappy", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "snappy-1.1.7-5.el8.src", + "release": "5.el8", + "nerva": "snappy-1.1.7-5.el8.x86_64" + }, + { + "srpm_name": "libmetalink", + "name": "libmetalink", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libmetalink-0.1.3-7.el8.src", + "release": "7.el8", + "nerva": "libmetalink-0.1.3-7.el8.x86_64" + }, + { + "srpm_name": "findutils", + "name": "findutils", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "findutils-4.6.0-20.el8.src", + "release": "20.el8", + "nerva": "findutils-1:4.6.0-20.el8.x86_64" + }, + { + "srpm_name": "ethtool", + "name": "ethtool", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "ethtool-4.16-1.el8.src", + "release": "1.el8", + "nerva": "ethtool-2:4.16-1.el8.x86_64" + }, + { + "srpm_name": "libmnl", + "name": "libmnl", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libmnl-1.0.4-6.el8.src", + "release": "6.el8", + "nerva": "libmnl-1.0.4-6.el8.x86_64" + }, + { + "srpm_name": "nghttp2", + "name": "libnghttp2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "nghttp2-1.33.0-1.el8.src", + "release": "1.el8", + "nerva": "libnghttp2-1.33.0-1.el8.x86_64" + }, + { + "srpm_name": "pkgconf", + "name": "pkgconf", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pkgconf-1.4.2-1.el8.src", + "release": "1.el8", + "nerva": "pkgconf-1.4.2-1.el8.x86_64" + }, + { + "srpm_name": "libpcap", + "name": "libpcap", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libpcap-1.9.0-1.el8.src", + "release": "1.el8", + "nerva": "libpcap-14:1.9.0-1.el8.x86_64" + }, + { + "srpm_name": "libseccomp", + "name": "libseccomp", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libseccomp-2.3.3-3.el8.src", + "release": "3.el8", + "nerva": "libseccomp-2.3.3-3.el8.x86_64" + }, + { + "srpm_name": "gawk", + "name": "gawk", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gawk-4.2.1-1.el8.src", + "release": "1.el8", + "nerva": "gawk-4.2.1-1.el8.x86_64" + }, + { + "srpm_name": "krb5", + "name": "krb5-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "krb5-1.16.1-22.el8.src", + "release": "22.el8", + "nerva": "krb5-libs-1.16.1-22.el8.x86_64" + }, + { + "srpm_name": "libnsl2", + "name": "libnsl2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libnsl2-1.2.0-2.20180605git4a062cf.el8.src", + "release": "2.20180605git4a062cf.el8", + "nerva": "libnsl2-1.2.0-2.20180605git4a062cf.el8.x86_64" + }, + { + "srpm_name": "python-setuptools", + "name": "platform-python-setuptools", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python-setuptools-39.2.0-4.el8.src", + "release": "4.el8", + "nerva": "platform-python-setuptools-39.2.0-4.el8.noarch" + }, + { + "srpm_name": "python3", + "name": "python3-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python3-3.6.8-1.el8.0.1.src", + "release": "1.el8.0.1", + "nerva": "python3-libs-3.6.8-1.el8.0.1.x86_64" + }, + { + "srpm_name": "pam", + "name": "pam", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "pam-1.3.1-4.el8.src", + "release": "4.el8", + "nerva": "pam-1.3.1-4.el8.x86_64" + }, + { + "srpm_name": "curl", + "name": "libcurl-minimal", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "curl-7.61.1-8.el8.src", + "release": "8.el8", + "nerva": "libcurl-minimal-7.61.1-8.el8.x86_64" + }, + { + "srpm_name": "rpm", + "name": "rpm", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "rpm-4.14.2-9.el8.src", + "release": "9.el8", + "nerva": "rpm-4.14.2-9.el8.x86_64" + }, + { + "srpm_name": "libsolv", + "name": "libsolv", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libsolv-0.6.35-6.el8.src", + "release": "6.el8", + "nerva": "libsolv-0.6.35-6.el8.x86_64" + }, + { + "srpm_name": "lvm2", + "name": "device-mapper-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "lvm2-2.03.02-6.el8.src", + "release": "6.el8", + "nerva": "device-mapper-libs-8:1.02.155-6.el8.x86_64" + }, + { + "srpm_name": "elfutils", + "name": "elfutils-default-yama-scope", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "elfutils-0.174-6.el8.src", + "release": "6.el8", + "nerva": "elfutils-default-yama-scope-0.174-6.el8.noarch" + }, + { + "srpm_name": "systemd", + "name": "systemd-pam", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "systemd-239-13.el8.src", + "release": "13.el8", + "nerva": "systemd-pam-239-13.el8.x86_64" + }, + { + "srpm_name": "dbus", + "name": "dbus", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dbus-1.12.8-7.el8.src", + "release": "7.el8", + "nerva": "dbus-1:1.12.8-7.el8.x86_64" + }, + { + "srpm_name": "libkcapi", + "name": "libkcapi", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libkcapi-1.1.1-16_1.el8.src", + "release": "16_1.el8", + "nerva": "libkcapi-1.1.1-16_1.el8.x86_64" + }, + { + "srpm_name": "systemd", + "name": "systemd-udev", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "systemd-239-13.el8.src", + "release": "13.el8", + "nerva": "systemd-udev-239-13.el8.x86_64" + }, + { + "srpm_name": "dracut", + "name": "dracut-squash", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dracut-049-10.git20190115.el8.src", + "release": "10.git20190115.el8", + "nerva": "dracut-squash-049-10.git20190115.el8.x86_64" + }, + { + "srpm_name": "python-six", + "name": "python3-six", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "python-six-1.11.0-8.el8.src", + "release": "8.el8", + "nerva": "python3-six-1.11.0-8.el8.noarch" + }, + { + "srpm_name": "bind", + "name": "bind-export-libs", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "bind-9.11.4-16.P2.el8.src", + "release": "16.P2.el8", + "nerva": "bind-export-libs-32:9.11.4-16.P2.el8.x86_64" + }, + { + "srpm_name": "dracut", + "name": "dracut-network", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dracut-049-10.git20190115.el8.src", + "release": "10.git20190115.el8", + "nerva": "dracut-network-049-10.git20190115.el8.x86_64" + }, + { + "srpm_name": "openldap", + "name": "openldap", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "openldap-2.4.46-9.el8.src", + "release": "9.el8", + "nerva": "openldap-2.4.46-9.el8.x86_64" + }, + { + "srpm_name": "libmodulemd", + "name": "libmodulemd1", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libmodulemd-2.0.0-5.el8.src", + "release": "5.el8", + "nerva": "libmodulemd1-1.8.0-5.el8.x86_64" + }, + { + "srpm_name": "gnupg2", + "name": "gnupg2", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gnupg2-2.2.9-1.el8.src", + "release": "1.el8", + "nerva": "gnupg2-2.2.9-1.el8.x86_64" + }, + { + "srpm_name": "librepo", + "name": "librepo", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "librepo-1.9.2-1.el8.src", + "release": "1.el8", + "nerva": "librepo-1.9.2-1.el8.x86_64" + }, + { + "srpm_name": "libdnf", + "name": "python3-libdnf", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "libdnf-0.22.5-4.el8.src", + "release": "4.el8", + "nerva": "python3-libdnf-0.22.5-4.el8.x86_64" + }, + { + "srpm_name": "gpgme", + "name": "python3-gpg", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "gpgme-1.10.0-6.el8.0.1.src", + "release": "6.el8.0.1", + "nerva": "python3-gpg-1.10.0-6.el8.0.1.x86_64" + }, + { + "srpm_name": "rpm", + "name": "python3-rpm", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "rpm-4.14.2-9.el8.src", + "release": "9.el8", + "nerva": "python3-rpm-4.14.2-9.el8.x86_64" + }, + { + "srpm_name": "dnf", + "name": "dnf", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "dnf-4.0.9.2-5.el8.src", + "release": "5.el8", + "nerva": "dnf-4.0.9.2-5.el8.noarch" + }, + { + "srpm_name": "kexec-tools", + "name": "kexec-tools", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "kexec-tools-2.0.17-28.el8.src", + "release": "28.el8", + "nerva": "kexec-tools-2.0.17-28.el8.x86_64" + }, + { + "srpm_name": "tar", + "name": "tar", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "tar-1.30-4.el8.src", + "release": "4.el8", + "nerva": "tar-2:1.30-4.el8.x86_64" + }, + { + "srpm_name": "hostname", + "name": "hostname", + "architecture": "x86_64", + "gpg": "05b555b38483c65d", + "srpm_nevra": "hostname-3.20-6.el8.src", + "release": "6.el8", + "nerva": "hostname-3.20-6.el8.x86_64" + }, + { + "srpm_name": "langpacks", + "name": "langpacks-en", + "architecture": "noarch", + "gpg": "05b555b38483c65d", + "srpm_nevra": "langpacks-1.0-12.el8.src", + "release": "12.el8", + "nerva": "langpacks-en-1.0-12.el8.noarch" + } + ] +} diff --git a/rhel/testdata/httpd-24_9.5-1734525854.rpm-manifest.json b/rhel/testdata/httpd-24_9.5-1734525854.rpm-manifest.json new file mode 100644 index 000000000..0554815d9 --- /dev/null +++ b/rhel/testdata/httpd-24_9.5-1734525854.rpm-manifest.json @@ -0,0 +1,2677 @@ +{ + "rpms": [ + { + "name": "acl", + "version": "2.3.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "acl", + "srpm_nevra": "acl-2.3.1-4.el9.src", + "release": "4.el9" + }, + { + "name": "alternatives", + "version": "1.24", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "chkconfig", + "srpm_nevra": "chkconfig-1.24-1.el9_5.1.src", + "release": "1.el9_5.1" + }, + { + "name": "apr", + "version": "1.7.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "apr", + "srpm_nevra": "apr-1.7.0-12.el9_3.src", + "release": "12.el9_3" + }, + { + "name": "apr-util", + "version": "1.6.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "apr-util", + "srpm_nevra": "apr-util-1.6.1-23.el9.src", + "release": "23.el9" + }, + { + "name": "apr-util-bdb", + "version": "1.6.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "apr-util", + "srpm_nevra": "apr-util-1.6.1-23.el9.src", + "release": "23.el9" + }, + { + "name": "apr-util-ldap", + "version": "1.6.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "apr-util", + "srpm_nevra": "apr-util-1.6.1-23.el9.src", + "release": "23.el9" + }, + { + "name": "apr-util-openssl", + "version": "1.6.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "apr-util", + "srpm_nevra": "apr-util-1.6.1-23.el9.src", + "release": "23.el9" + }, + { + "name": "attr", + "version": "2.5.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "attr", + "srpm_nevra": "attr-2.5.1-3.el9.src", + "release": "3.el9" + }, + { + "name": "audit-libs", + "version": "3.1.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "audit", + "srpm_nevra": "audit-3.1.5-1.el9.src", + "release": "1.el9" + }, + { + "name": "basesystem", + "version": "11", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "basesystem", + "srpm_nevra": "basesystem-11-13.el9.src", + "release": "13.el9" + }, + { + "name": "bash", + "version": "5.1.8", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "bash", + "srpm_nevra": "bash-5.1.8-9.el9.src", + "release": "9.el9" + }, + { + "name": "bind-libs", + "version": "32:9.16.23", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "bind", + "srpm_nevra": "bind-9.16.23-24.el9_5.src", + "release": "24.el9_5" + }, + { + "name": "bind-license", + "version": "32:9.16.23", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "bind", + "srpm_nevra": "bind-9.16.23-24.el9_5.src", + "release": "24.el9_5" + }, + { + "name": "bind-utils", + "version": "32:9.16.23", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "bind", + "srpm_nevra": "bind-9.16.23-24.el9_5.src", + "release": "24.el9_5" + }, + { + "name": "bsdtar", + "version": "3.5.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libarchive", + "srpm_nevra": "libarchive-3.5.3-4.el9.src", + "release": "4.el9" + }, + { + "name": "bzip2-libs", + "version": "1.0.8", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "bzip2", + "srpm_nevra": "bzip2-1.0.8-8.el9.src", + "release": "8.el9" + }, + { + "name": "ca-certificates", + "version": "2024.2.69_v8.0.303", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "ca-certificates", + "srpm_nevra": "ca-certificates-2024.2.69_v8.0.303-91.4.el9_4.src", + "release": "91.4.el9_4" + }, + { + "name": "coreutils-single", + "version": "8.32", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "coreutils", + "srpm_nevra": "coreutils-8.32-36.el9.src", + "release": "36.el9" + }, + { + "name": "cracklib", + "version": "2.9.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "cracklib", + "srpm_nevra": "cracklib-2.9.6-27.el9.src", + "release": "27.el9" + }, + { + "name": "cracklib-dicts", + "version": "2.9.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "cracklib", + "srpm_nevra": "cracklib-2.9.6-27.el9.src", + "release": "27.el9" + }, + { + "name": "crypto-policies", + "version": "20240828", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "crypto-policies", + "srpm_nevra": "crypto-policies-20240828-2.git626aa59.el9_5.src", + "release": "2.git626aa59.el9_5" + }, + { + "name": "crypto-policies-scripts", + "version": "20240828", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "crypto-policies", + "srpm_nevra": "crypto-policies-20240828-2.git626aa59.el9_5.src", + "release": "2.git626aa59.el9_5" + }, + { + "name": "curl-minimal", + "version": "7.76.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "curl", + "srpm_nevra": "curl-7.76.1-31.el9.src", + "release": "31.el9" + }, + { + "name": "cyrus-sasl-lib", + "version": "2.1.27", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "cyrus-sasl", + "srpm_nevra": "cyrus-sasl-2.1.27-21.el9.src", + "release": "21.el9" + }, + { + "name": "dbus", + "version": "1:1.12.20", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1.12.20-8.el9.src", + "release": "8.el9" + }, + { + "name": "dbus-broker", + "version": "28", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "dbus-broker", + "srpm_nevra": "dbus-broker-28-7.el9.src", + "release": "7.el9" + }, + { + "name": "dbus-common", + "version": "1:1.12.20", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1.12.20-8.el9.src", + "release": "8.el9" + }, + { + "name": "dbus-libs", + "version": "1:1.12.20", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1.12.20-8.el9.src", + "release": "8.el9" + }, + { + "name": "dejavu-sans-fonts", + "version": "2.37", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dejavu-fonts", + "srpm_nevra": "dejavu-fonts-2.37-18.el9.src", + "release": "18.el9" + }, + { + "name": "dmidecode", + "version": "1:3.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "dmidecode", + "srpm_nevra": "dmidecode-3.6-1.el9.src", + "release": "1.el9" + }, + { + "name": "dnf", + "version": "4.14.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dnf", + "srpm_nevra": "dnf-4.14.0-17.el9.src", + "release": "17.el9" + }, + { + "name": "dnf-data", + "version": "4.14.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dnf", + "srpm_nevra": "dnf-4.14.0-17.el9.src", + "release": "17.el9" + }, + { + "name": "elfutils-default-yama-scope", + "version": "0.191", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0.191-4.el9.src", + "release": "4.el9" + }, + { + "name": "elfutils-libelf", + "version": "0.191", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0.191-4.el9.src", + "release": "4.el9" + }, + { + "name": "elfutils-libs", + "version": "0.191", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0.191-4.el9.src", + "release": "4.el9" + }, + { + "name": "environment-modules", + "version": "5.3.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "environment-modules", + "srpm_nevra": "environment-modules-5.3.0-1.el9.src", + "release": "1.el9" + }, + { + "name": "expat", + "version": "2.5.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "expat", + "srpm_nevra": "expat-2.5.0-3.el9_5.1.src", + "release": "3.el9_5.1" + }, + { + "name": "file-libs", + "version": "5.39", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "file", + "srpm_nevra": "file-5.39-16.el9.src", + "release": "16.el9" + }, + { + "name": "filesystem", + "version": "3.16", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "filesystem", + "srpm_nevra": "filesystem-3.16-5.el9.src", + "release": "5.el9" + }, + { + "name": "findutils", + "version": "1:4.8.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "findutils", + "srpm_nevra": "findutils-4.8.0-7.el9.src", + "release": "7.el9" + }, + { + "name": "fonts-filesystem", + "version": "1:2.0.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "fonts-rpm-macros", + "srpm_nevra": "fonts-rpm-macros-2.0.5-7.el9.1.src", + "release": "7.el9.1" + }, + { + "name": "fstrm", + "version": "0.6.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "fstrm", + "srpm_nevra": "fstrm-0.6.1-3.el9.src", + "release": "3.el9" + }, + { + "name": "gawk", + "version": "5.1.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gawk", + "srpm_nevra": "gawk-5.1.0-6.el9.src", + "release": "6.el9" + }, + { + "name": "gdb-gdbserver", + "version": "14.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gdb", + "srpm_nevra": "gdb-14.2-3.el9.src", + "release": "3.el9" + }, + { + "name": "gdbm-libs", + "version": "1:1.23", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gdbm", + "srpm_nevra": "gdbm-1.23-1.el9.src", + "release": "1.el9" + }, + { + "name": "gettext", + "version": "0.21", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gettext", + "srpm_nevra": "gettext-0.21-8.el9.src", + "release": "8.el9" + }, + { + "name": "gettext-libs", + "version": "0.21", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gettext", + "srpm_nevra": "gettext-0.21-8.el9.src", + "release": "8.el9" + }, + { + "name": "glib2", + "version": "2.68.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glib2", + "srpm_nevra": "glib2-2.68.4-14.el9_4.1.src", + "release": "14.el9_4.1" + }, + { + "name": "glibc", + "version": "2.34", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glibc", + "srpm_nevra": "glibc-2.34-125.el9_5.1.src", + "release": "125.el9_5.1" + }, + { + "name": "glibc-common", + "version": "2.34", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glibc", + "srpm_nevra": "glibc-2.34-125.el9_5.1.src", + "release": "125.el9_5.1" + }, + { + "name": "glibc-langpack-en", + "version": "2.34", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glibc", + "srpm_nevra": "glibc-2.34-125.el9_5.1.src", + "release": "125.el9_5.1" + }, + { + "name": "glibc-locale-source", + "version": "2.34", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glibc", + "srpm_nevra": "glibc-2.34-125.el9_5.1.src", + "release": "125.el9_5.1" + }, + { + "name": "glibc-minimal-langpack", + "version": "2.34", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "glibc", + "srpm_nevra": "glibc-2.34-125.el9_5.1.src", + "release": "125.el9_5.1" + }, + { + "name": "gmp", + "version": "1:6.2.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gmp", + "srpm_nevra": "gmp-6.2.0-13.el9.src", + "release": "13.el9" + }, + { + "name": "gnupg2", + "version": "2.3.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gnupg2", + "srpm_nevra": "gnupg2-2.3.3-4.el9.src", + "release": "4.el9" + }, + { + "name": "gnutls", + "version": "3.8.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gnutls", + "srpm_nevra": "gnutls-3.8.3-4.el9_4.src", + "release": "4.el9_4" + }, + { + "name": "gobject-introspection", + "version": "1.68.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gobject-introspection", + "srpm_nevra": "gobject-introspection-1.68.0-11.el9.src", + "release": "11.el9" + }, + { + "name": "gpgme", + "version": "1.15.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gpgme", + "srpm_nevra": "gpgme-1.15.1-6.el9.src", + "release": "6.el9" + }, + { + "name": "grep", + "version": "3.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "grep", + "srpm_nevra": "grep-3.6-5.el9.src", + "release": "5.el9" + }, + { + "name": "groff-base", + "version": "1.22.4", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "groff", + "srpm_nevra": "groff-1.22.4-10.el9.src", + "release": "10.el9" + }, + { + "name": "gzip", + "version": "1.12", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gzip", + "srpm_nevra": "gzip-1.12-1.el9.src", + "release": "1.el9" + }, + { + "name": "hostname", + "version": "3.23", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "hostname", + "srpm_nevra": "hostname-3.23-6.el9.src", + "release": "6.el9" + }, + { + "name": "httpd", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "httpd-core", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "httpd-filesystem", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "httpd-tools", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "ima-evm-utils", + "version": "1.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "ima-evm-utils", + "srpm_nevra": "ima-evm-utils-1.5-2.el9.src", + "release": "2.el9" + }, + { + "name": "iproute", + "version": "6.2.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "iproute", + "srpm_nevra": "iproute-6.2.0-6.el9_4.src", + "release": "6.el9_4" + }, + { + "name": "json-c", + "version": "0.14", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "json-c", + "srpm_nevra": "json-c-0.14-11.el9.src", + "release": "11.el9" + }, + { + "name": "json-glib", + "version": "1.6.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "json-glib", + "srpm_nevra": "json-glib-1.6.6-1.el9.src", + "release": "1.el9" + }, + { + "name": "keyutils", + "version": "1.6.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "keyutils", + "srpm_nevra": "keyutils-1.6.3-1.el9.src", + "release": "1.el9" + }, + { + "name": "keyutils-libs", + "version": "1.6.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "keyutils", + "srpm_nevra": "keyutils-1.6.3-1.el9.src", + "release": "1.el9" + }, + { + "name": "kmod-libs", + "version": "28", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "kmod", + "srpm_nevra": "kmod-28-10.el9.src", + "release": "10.el9" + }, + { + "name": "krb5-libs", + "version": "1.21.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "krb5", + "srpm_nevra": "krb5-1.21.1-4.el9_5.src", + "release": "4.el9_5" + }, + { + "name": "langpacks-core-en", + "version": "3.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-3.0-16.el9.src", + "release": "16.el9" + }, + { + "name": "langpacks-core-font-en", + "version": "3.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-3.0-16.el9.src", + "release": "16.el9" + }, + { + "name": "langpacks-en", + "version": "3.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-3.0-16.el9.src", + "release": "16.el9" + }, + { + "name": "lasso", + "version": "2.7.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "lasso", + "srpm_nevra": "lasso-2.7.0-11.el9.src", + "release": "11.el9" + }, + { + "name": "less", + "version": "590", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "less", + "srpm_nevra": "less-590-5.el9.src", + "release": "5.el9" + }, + { + "name": "libacl", + "version": "2.3.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "acl", + "srpm_nevra": "acl-2.3.1-4.el9.src", + "release": "4.el9" + }, + { + "name": "libarchive", + "version": "3.5.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libarchive", + "srpm_nevra": "libarchive-3.5.3-4.el9.src", + "release": "4.el9" + }, + { + "name": "libassuan", + "version": "2.5.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libassuan", + "srpm_nevra": "libassuan-2.5.5-3.el9.src", + "release": "3.el9" + }, + { + "name": "libattr", + "version": "2.5.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "attr", + "srpm_nevra": "attr-2.5.1-3.el9.src", + "release": "3.el9" + }, + { + "name": "libblkid", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "libbpf", + "version": "2:1.4.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libbpf", + "srpm_nevra": "libbpf-1.4.0-1.el9.src", + "release": "1.el9" + }, + { + "name": "libbrotli", + "version": "1.0.9", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "brotli", + "srpm_nevra": "brotli-1.0.9-7.el9_5.src", + "release": "7.el9_5" + }, + { + "name": "libcap", + "version": "2.48", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libcap", + "srpm_nevra": "libcap-2.48-9.el9_2.src", + "release": "9.el9_2" + }, + { + "name": "libcap-ng", + "version": "0.8.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libcap-ng", + "srpm_nevra": "libcap-ng-0.8.2-7.el9.src", + "release": "7.el9" + }, + { + "name": "libcom_err", + "version": "1.46.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "e2fsprogs", + "srpm_nevra": "e2fsprogs-1.46.5-5.el9.src", + "release": "5.el9" + }, + { + "name": "libcomps", + "version": "0.1.18", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libcomps", + "srpm_nevra": "libcomps-0.1.18-1.el9.src", + "release": "1.el9" + }, + { + "name": "libcurl-minimal", + "version": "7.76.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "curl", + "srpm_nevra": "curl-7.76.1-31.el9.src", + "release": "31.el9" + }, + { + "name": "libdb", + "version": "5.3.28", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libdb", + "srpm_nevra": "libdb-5.3.28-54.el9.src", + "release": "54.el9" + }, + { + "name": "libdnf", + "version": "0.69.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0.69.0-12.el9.src", + "release": "12.el9" + }, + { + "name": "libdnf-plugin-subscription-manager", + "version": "1.29.42", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-1.29.42-1.el9.src", + "release": "1.el9" + }, + { + "name": "libeconf", + "version": "0.4.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libeconf", + "srpm_nevra": "libeconf-0.4.1-4.el9.src", + "release": "4.el9" + }, + { + "name": "libevent", + "version": "2.1.12", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libevent", + "srpm_nevra": "libevent-2.1.12-8.el9_4.src", + "release": "8.el9_4" + }, + { + "name": "libfdisk", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "libffi", + "version": "3.4.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libffi", + "srpm_nevra": "libffi-3.4.2-8.el9.src", + "release": "8.el9" + }, + { + "name": "libgcc", + "version": "11.5.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gcc", + "srpm_nevra": "gcc-11.5.0-2.el9.src", + "release": "2.el9" + }, + { + "name": "libgcrypt", + "version": "1.10.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libgcrypt", + "srpm_nevra": "libgcrypt-1.10.0-11.el9.src", + "release": "11.el9" + }, + { + "name": "libgomp", + "version": "11.5.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gcc", + "srpm_nevra": "gcc-11.5.0-2.el9.src", + "release": "2.el9" + }, + { + "name": "libgpg-error", + "version": "1.42", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libgpg-error", + "srpm_nevra": "libgpg-error-1.42-5.el9.src", + "release": "5.el9" + }, + { + "name": "libidn2", + "version": "2.3.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libidn2", + "srpm_nevra": "libidn2-2.3.0-7.el9.src", + "release": "7.el9" + }, + { + "name": "libksba", + "version": "1.5.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libksba", + "srpm_nevra": "libksba-1.5.1-7.el9.src", + "release": "7.el9" + }, + { + "name": "libmaxminddb", + "version": "1.5.2", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libmaxminddb", + "srpm_nevra": "libmaxminddb-1.5.2-4.el9.src", + "release": "4.el9" + }, + { + "name": "libmnl", + "version": "1.0.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libmnl", + "srpm_nevra": "libmnl-1.0.4-16.el9_4.src", + "release": "16.el9_4" + }, + { + "name": "libmodulemd", + "version": "2.13.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libmodulemd", + "srpm_nevra": "libmodulemd-2.13.0-2.el9.src", + "release": "2.el9" + }, + { + "name": "libmount", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "libnghttp2", + "version": "1.43.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "nghttp2", + "srpm_nevra": "nghttp2-1.43.0-6.el9.src", + "release": "6.el9" + }, + { + "name": "libpath_utils", + "version": "0.2.1", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "ding-libs", + "srpm_nevra": "ding-libs-0.6.1-53.el9.src", + "release": "53.el9" + }, + { + "name": "libpipeline", + "version": "1.5.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libpipeline", + "srpm_nevra": "libpipeline-1.5.3-4.el9.src", + "release": "4.el9" + }, + { + "name": "libpwquality", + "version": "1.4.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libpwquality", + "srpm_nevra": "libpwquality-1.4.4-8.el9.src", + "release": "8.el9" + }, + { + "name": "librepo", + "version": "1.14.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "librepo", + "srpm_nevra": "librepo-1.14.5-2.el9.src", + "release": "2.el9" + }, + { + "name": "libreport-filesystem", + "version": "2.15.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "libreport", + "srpm_nevra": "libreport-2.15.2-6.el9.src", + "release": "6.el9" + }, + { + "name": "librhsm", + "version": "0.0.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "librhsm", + "srpm_nevra": "librhsm-0.0.3-9.el9.src", + "release": "9.el9" + }, + { + "name": "libseccomp", + "version": "2.5.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libseccomp", + "srpm_nevra": "libseccomp-2.5.2-2.el9.src", + "release": "2.el9" + }, + { + "name": "libselinux", + "version": "3.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libselinux", + "srpm_nevra": "libselinux-3.6-1.el9.src", + "release": "1.el9" + }, + { + "name": "libsemanage", + "version": "3.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libsemanage", + "srpm_nevra": "libsemanage-3.6-2.1.el9_5.src", + "release": "2.1.el9_5" + }, + { + "name": "libsepol", + "version": "3.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libsepol", + "srpm_nevra": "libsepol-3.6-1.el9.src", + "release": "1.el9" + }, + { + "name": "libsigsegv", + "version": "2.13", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libsigsegv", + "srpm_nevra": "libsigsegv-2.13-4.el9.src", + "release": "4.el9" + }, + { + "name": "libsmartcols", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "libsolv", + "version": "0.7.24", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libsolv", + "srpm_nevra": "libsolv-0.7.24-3.el9.src", + "release": "3.el9" + }, + { + "name": "libstdc++", + "version": "11.5.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gcc", + "srpm_nevra": "gcc-11.5.0-2.el9.src", + "release": "2.el9" + }, + { + "name": "libtalloc", + "version": "2.4.2", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libtalloc", + "srpm_nevra": "libtalloc-2.4.2-1.el9.src", + "release": "1.el9" + }, + { + "name": "libtasn1", + "version": "4.16.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libtasn1", + "srpm_nevra": "libtasn1-4.16.0-8.el9_1.src", + "release": "8.el9_1" + }, + { + "name": "libtool-ltdl", + "version": "2.4.6", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libtool", + "srpm_nevra": "libtool-2.4.6-46.el9.src", + "release": "46.el9" + }, + { + "name": "libunistring", + "version": "0.9.10", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libunistring", + "srpm_nevra": "libunistring-0.9.10-15.el9.src", + "release": "15.el9" + }, + { + "name": "libuser", + "version": "0.63", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libuser", + "srpm_nevra": "libuser-0.63-15.el9.src", + "release": "15.el9" + }, + { + "name": "libutempter", + "version": "1.2.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libutempter", + "srpm_nevra": "libutempter-1.2.1-6.el9.src", + "release": "6.el9" + }, + { + "name": "libuuid", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "libuv", + "version": "1:1.42.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libuv", + "srpm_nevra": "libuv-1.42.0-2.el9_4.src", + "release": "2.el9_4" + }, + { + "name": "libverto", + "version": "0.3.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libverto", + "srpm_nevra": "libverto-0.3.2-3.el9.src", + "release": "3.el9" + }, + { + "name": "libxcrypt", + "version": "4.4.18", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libxcrypt", + "srpm_nevra": "libxcrypt-4.4.18-3.el9.src", + "release": "3.el9" + }, + { + "name": "libxml2", + "version": "2.9.13", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libxml2", + "srpm_nevra": "libxml2-2.9.13-6.el9_4.src", + "release": "6.el9_4" + }, + { + "name": "libxslt", + "version": "1.1.34", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libxslt", + "srpm_nevra": "libxslt-1.1.34-9.el9.src", + "release": "9.el9" + }, + { + "name": "libyaml", + "version": "0.2.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libyaml", + "srpm_nevra": "libyaml-0.2.5-7.el9.src", + "release": "7.el9" + }, + { + "name": "libzstd", + "version": "1.5.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "zstd", + "srpm_nevra": "zstd-1.5.1-2.el9.src", + "release": "2.el9" + }, + { + "name": "lmdb-libs", + "version": "0.9.29", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "lmdb", + "srpm_nevra": "lmdb-0.9.29-3.el9.src", + "release": "3.el9" + }, + { + "name": "lua-libs", + "version": "5.4.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "lua", + "srpm_nevra": "lua-5.4.4-4.el9.src", + "release": "4.el9" + }, + { + "name": "lz4-libs", + "version": "1.9.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "lz4", + "srpm_nevra": "lz4-1.9.3-5.el9.src", + "release": "5.el9" + }, + { + "name": "mailcap", + "version": "2.1.49", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "mailcap", + "srpm_nevra": "mailcap-2.1.49-5.el9.src", + "release": "5.el9" + }, + { + "name": "man-db", + "version": "2.9.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "man-db", + "srpm_nevra": "man-db-2.9.3-7.el9.src", + "release": "7.el9" + }, + { + "name": "mod_auth_mellon", + "version": "0.17.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "mod_auth_mellon", + "srpm_nevra": "mod_auth_mellon-0.17.0-7.el9.src", + "release": "7.el9" + }, + { + "name": "mod_http2", + "version": "2.0.26", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "mod_http2", + "srpm_nevra": "mod_http2-2.0.26-2.el9_4.1.src", + "release": "2.el9_4.1" + }, + { + "name": "mod_ldap", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "mod_lua", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "mod_security", + "version": "2.9.6", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "mod_security", + "srpm_nevra": "mod_security-2.9.6-1.el9.src", + "release": "1.el9" + }, + { + "name": "mod_session", + "version": "2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "mod_ssl", + "version": "1:2.4.62", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "httpd", + "srpm_nevra": "httpd-2.4.62-1.el9.src", + "release": "1.el9" + }, + { + "name": "mpfr", + "version": "4.1.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "mpfr", + "srpm_nevra": "mpfr-4.1.0-7.el9.src", + "release": "7.el9" + }, + { + "name": "ncurses-base", + "version": "6.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "ncurses", + "srpm_nevra": "ncurses-6.2-10.20210508.el9.src", + "release": "10.20210508.el9" + }, + { + "name": "ncurses-libs", + "version": "6.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "ncurses", + "srpm_nevra": "ncurses-6.2-10.20210508.el9.src", + "release": "10.20210508.el9" + }, + { + "name": "nettle", + "version": "3.9.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "nettle", + "srpm_nevra": "nettle-3.9.1-1.el9.src", + "release": "1.el9" + }, + { + "name": "npth", + "version": "1.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "npth", + "srpm_nevra": "npth-1.6-8.el9.src", + "release": "8.el9" + }, + { + "name": "nss_wrapper-libs", + "version": "1.1.13", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "nss_wrapper", + "srpm_nevra": "nss_wrapper-1.1.13-1.el9.src", + "release": "1.el9" + }, + { + "name": "openldap", + "version": "2.6.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "openldap", + "srpm_nevra": "openldap-2.6.6-3.el9.src", + "release": "3.el9" + }, + { + "name": "openssl", + "version": "1:3.2.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "openssl", + "srpm_nevra": "openssl-3.2.2-6.el9_5.src", + "release": "6.el9_5" + }, + { + "name": "openssl-fips-provider", + "version": "3.0.7", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "openssl-fips-provider", + "srpm_nevra": "openssl-fips-provider-3.0.7-6.el9_5.src", + "release": "6.el9_5" + }, + { + "name": "openssl-fips-provider-so", + "version": "3.0.7", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "openssl-fips-provider", + "srpm_nevra": "openssl-fips-provider-3.0.7-6.el9_5.src", + "release": "6.el9_5" + }, + { + "name": "openssl-libs", + "version": "1:3.2.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "openssl", + "srpm_nevra": "openssl-3.2.2-6.el9_5.src", + "release": "6.el9_5" + }, + { + "name": "p11-kit", + "version": "0.25.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "p11-kit", + "srpm_nevra": "p11-kit-0.25.3-3.el9_5.src", + "release": "3.el9_5" + }, + { + "name": "p11-kit-trust", + "version": "0.25.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "p11-kit", + "srpm_nevra": "p11-kit-0.25.3-3.el9_5.src", + "release": "3.el9_5" + }, + { + "name": "pam", + "version": "1.5.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "pam", + "srpm_nevra": "pam-1.5.1-22.el9_5.src", + "release": "22.el9_5" + }, + { + "name": "passwd", + "version": "0.80", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "passwd", + "srpm_nevra": "passwd-0.80-12.el9.src", + "release": "12.el9" + }, + { + "name": "pcre", + "version": "8.44", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "pcre", + "srpm_nevra": "pcre-8.44-4.el9.src", + "release": "4.el9" + }, + { + "name": "pcre2", + "version": "10.40", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "pcre2", + "srpm_nevra": "pcre2-10.40-6.el9.src", + "release": "6.el9" + }, + { + "name": "pcre2-syntax", + "version": "10.40", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "pcre2", + "srpm_nevra": "pcre2-10.40-6.el9.src", + "release": "6.el9" + }, + { + "name": "popt", + "version": "1.18", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "popt", + "srpm_nevra": "popt-1.18-8.el9.src", + "release": "8.el9" + }, + { + "name": "procps-ng", + "version": "3.3.17", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "procps-ng", + "srpm_nevra": "procps-ng-3.3.17-14.el9.src", + "release": "14.el9" + }, + { + "name": "protobuf-c", + "version": "1.3.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "protobuf-c", + "srpm_nevra": "protobuf-c-1.3.3-13.el9.src", + "release": "13.el9" + }, + { + "name": "psmisc", + "version": "23.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "psmisc", + "srpm_nevra": "psmisc-23.4-3.el9.src", + "release": "3.el9" + }, + { + "name": "python3", + "version": "3.9.21", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "python3.9", + "srpm_nevra": "python3.9-3.9.21-1.el9_5.src", + "release": "1.el9_5" + }, + { + "name": "python3-chardet", + "version": "4.0.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-chardet", + "srpm_nevra": "python-chardet-4.0.0-5.el9.src", + "release": "5.el9" + }, + { + "name": "python3-cloud-what", + "version": "1.29.42", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-1.29.42-1.el9.src", + "release": "1.el9" + }, + { + "name": "python3-dateutil", + "version": "1:2.8.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-dateutil", + "srpm_nevra": "python-dateutil-2.8.1-7.el9.src", + "release": "7.el9" + }, + { + "name": "python3-dbus", + "version": "1.2.18", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "dbus-python", + "srpm_nevra": "dbus-python-1.2.18-2.el9.src", + "release": "2.el9" + }, + { + "name": "python3-decorator", + "version": "4.4.2", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-decorator", + "srpm_nevra": "python-decorator-4.4.2-6.el9.src", + "release": "6.el9" + }, + { + "name": "python3-dnf", + "version": "4.14.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dnf", + "srpm_nevra": "dnf-4.14.0-17.el9.src", + "release": "17.el9" + }, + { + "name": "python3-dnf-plugins-core", + "version": "4.3.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dnf-plugins-core", + "srpm_nevra": "dnf-plugins-core-4.3.0-16.el9.src", + "release": "16.el9" + }, + { + "name": "python3-gobject-base", + "version": "3.40.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "pygobject3", + "srpm_nevra": "pygobject3-3.40.1-6.el9.src", + "release": "6.el9" + }, + { + "name": "python3-gobject-base-noarch", + "version": "3.40.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "pygobject3", + "srpm_nevra": "pygobject3-3.40.1-6.el9.src", + "release": "6.el9" + }, + { + "name": "python3-gpg", + "version": "1.15.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "gpgme", + "srpm_nevra": "gpgme-1.15.1-6.el9.src", + "release": "6.el9" + }, + { + "name": "python3-hawkey", + "version": "0.69.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0.69.0-12.el9.src", + "release": "12.el9" + }, + { + "name": "python3-idna", + "version": "2.10", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-idna", + "srpm_nevra": "python-idna-2.10-7.el9_4.1.src", + "release": "7.el9_4.1" + }, + { + "name": "python3-iniparse", + "version": "0.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-iniparse", + "srpm_nevra": "python-iniparse-0.4-45.el9.src", + "release": "45.el9" + }, + { + "name": "python3-inotify", + "version": "0.9.6", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-inotify", + "srpm_nevra": "python-inotify-0.9.6-25.el9.src", + "release": "25.el9" + }, + { + "name": "python3-libcomps", + "version": "0.1.18", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libcomps", + "srpm_nevra": "libcomps-0.1.18-1.el9.src", + "release": "1.el9" + }, + { + "name": "python3-libdnf", + "version": "0.69.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0.69.0-12.el9.src", + "release": "12.el9" + }, + { + "name": "python3-librepo", + "version": "1.14.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "librepo", + "srpm_nevra": "librepo-1.14.5-2.el9.src", + "release": "2.el9" + }, + { + "name": "python3-libs", + "version": "3.9.21", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "python3.9", + "srpm_nevra": "python3.9-3.9.21-1.el9_5.src", + "release": "1.el9_5" + }, + { + "name": "python3-pip-wheel", + "version": "21.3.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-pip", + "srpm_nevra": "python-pip-21.3.1-1.el9.src", + "release": "1.el9" + }, + { + "name": "python3-pysocks", + "version": "1.7.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-pysocks", + "srpm_nevra": "python-pysocks-1.7.1-12.el9.src", + "release": "12.el9" + }, + { + "name": "python3-requests", + "version": "2.25.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-requests", + "srpm_nevra": "python-requests-2.25.1-8.el9.src", + "release": "8.el9" + }, + { + "name": "python3-rpm", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "python3-setuptools", + "version": "53.0.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-setuptools", + "srpm_nevra": "python-setuptools-53.0.0-13.el9.src", + "release": "13.el9" + }, + { + "name": "python3-setuptools-wheel", + "version": "53.0.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-setuptools", + "srpm_nevra": "python-setuptools-53.0.0-13.el9.src", + "release": "13.el9" + }, + { + "name": "python3-six", + "version": "1.15.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-six", + "srpm_nevra": "python-six-1.15.0-9.el9.src", + "release": "9.el9" + }, + { + "name": "python3-subscription-manager-rhsm", + "version": "1.29.42", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-1.29.42-1.el9.src", + "release": "1.el9" + }, + { + "name": "python3-systemd", + "version": "234", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-systemd", + "srpm_nevra": "python-systemd-234-19.el9.src", + "release": "19.el9" + }, + { + "name": "python3-urllib3", + "version": "1.26.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "python-urllib3", + "srpm_nevra": "python-urllib3-1.26.5-6.el9.src", + "release": "6.el9" + }, + { + "name": "readline", + "version": "8.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "readline", + "srpm_nevra": "readline-8.1-4.el9.src", + "release": "4.el9" + }, + { + "name": "redhat-logos-httpd", + "version": "90.4", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "redhat-logos", + "srpm_nevra": "redhat-logos-90.4-2.el9.src", + "release": "2.el9" + }, + { + "name": "redhat-release", + "version": "9.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "redhat-release", + "srpm_nevra": "redhat-release-9.5-0.6.el9.src", + "release": "0.6.el9" + }, + { + "name": "rootfiles", + "version": "8.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "rootfiles", + "srpm_nevra": "rootfiles-8.1-31.el9.src", + "release": "31.el9" + }, + { + "name": "rpm", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "rpm-build-libs", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "rpm-libs", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "rpm-plugin-selinux", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "rpm-sign-libs", + "version": "4.16.1.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rpm", + "srpm_nevra": "rpm-4.16.1.3-34.el9.src", + "release": "34.el9" + }, + { + "name": "rsync", + "version": "3.2.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "rsync", + "srpm_nevra": "rsync-3.2.3-20.el9.src", + "release": "20.el9" + }, + { + "name": "scl-utils", + "version": "1:2.0.3", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "scl-utils", + "srpm_nevra": "scl-utils-2.0.3-4.el9.src", + "release": "4.el9" + }, + { + "name": "sed", + "version": "4.8", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "sed", + "srpm_nevra": "sed-4.8-9.el9.src", + "release": "9.el9" + }, + { + "name": "selinux-policy", + "version": "38.1.45", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "selinux-policy", + "srpm_nevra": "selinux-policy-38.1.45-3.el9_5.src", + "release": "3.el9_5" + }, + { + "name": "selinux-policy-targeted", + "version": "38.1.45", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "selinux-policy", + "srpm_nevra": "selinux-policy-38.1.45-3.el9_5.src", + "release": "3.el9_5" + }, + { + "name": "setup", + "version": "2.13.7", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "setup", + "srpm_nevra": "setup-2.13.7-10.el9.src", + "release": "10.el9" + }, + { + "name": "shadow-utils", + "version": "2:4.9", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "shadow-utils", + "srpm_nevra": "shadow-utils-4.9-10.el9_5.src", + "release": "10.el9_5" + }, + { + "name": "sqlite-libs", + "version": "3.34.1", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "sqlite", + "srpm_nevra": "sqlite-3.34.1-7.el9_3.src", + "release": "7.el9_3" + }, + { + "name": "sscg", + "version": "3.0.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "sscg", + "srpm_nevra": "sscg-3.0.0-7.el9.src", + "release": "7.el9" + }, + { + "name": "subscription-manager", + "version": "1.29.42", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-1.29.42-1.el9.src", + "release": "1.el9" + }, + { + "name": "subscription-manager-rhsm-certificates", + "version": "20220623", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "subscription-manager-rhsm-certificates", + "srpm_nevra": "subscription-manager-rhsm-certificates-20220623-1.el9.src", + "release": "1.el9" + }, + { + "name": "systemd", + "version": "252", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "systemd", + "srpm_nevra": "systemd-252-46.el9_5.2.src", + "release": "46.el9_5.2" + }, + { + "name": "systemd-libs", + "version": "252", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "systemd", + "srpm_nevra": "systemd-252-46.el9_5.2.src", + "release": "46.el9_5.2" + }, + { + "name": "systemd-pam", + "version": "252", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "systemd", + "srpm_nevra": "systemd-252-46.el9_5.2.src", + "release": "46.el9_5.2" + }, + { + "name": "systemd-rpm-macros", + "version": "252", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "systemd", + "srpm_nevra": "systemd-252-46.el9_5.2.src", + "release": "46.el9_5.2" + }, + { + "name": "tar", + "version": "2:1.34", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "tar", + "srpm_nevra": "tar-1.34-7.el9.src", + "release": "7.el9" + }, + { + "name": "tcl", + "version": "1:8.6.10", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "tcl", + "srpm_nevra": "tcl-8.6.10-7.el9.src", + "release": "7.el9" + }, + { + "name": "tpm2-tss", + "version": "3.2.3", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "tpm2-tss", + "srpm_nevra": "tpm2-tss-3.2.3-1.el9.src", + "release": "1.el9" + }, + { + "name": "tzdata", + "version": "2024b", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "tzdata", + "srpm_nevra": "tzdata-2024b-2.el9.src", + "release": "2.el9" + }, + { + "name": "unzip", + "version": "6.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "unzip", + "srpm_nevra": "unzip-6.0-57.el9.src", + "release": "57.el9" + }, + { + "name": "usermode", + "version": "1.114", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "usermode", + "srpm_nevra": "usermode-1.114-5.el9.src", + "release": "5.el9" + }, + { + "name": "util-linux", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "util-linux-core", + "version": "2.37.4", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-2.37.4-20.el9.src", + "release": "20.el9" + }, + { + "name": "vim-filesystem", + "version": "2:8.2.2637", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "vim", + "srpm_nevra": "vim-8.2.2637-21.el9.src", + "release": "21.el9" + }, + { + "name": "vim-minimal", + "version": "2:8.2.2637", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "vim", + "srpm_nevra": "vim-8.2.2637-21.el9.src", + "release": "21.el9" + }, + { + "name": "virt-what", + "version": "1.25", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "virt-what", + "srpm_nevra": "virt-what-1.25-10.el9.src", + "release": "10.el9" + }, + { + "name": "which", + "version": "2.21", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "which", + "srpm_nevra": "which-2.21-29.el9.src", + "release": "29.el9" + }, + { + "name": "xmlsec1", + "version": "1.2.29", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "xmlsec1", + "srpm_nevra": "xmlsec1-1.2.29-13.el9.src", + "release": "13.el9" + }, + { + "name": "xmlsec1-openssl", + "version": "1.2.29", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "xmlsec1", + "srpm_nevra": "xmlsec1-1.2.29-13.el9.src", + "release": "13.el9" + }, + { + "name": "xz", + "version": "5.2.5", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-baseos-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "xz", + "srpm_nevra": "xz-5.2.5-8.el9_0.src", + "release": "8.el9_0" + }, + { + "name": "xz-libs", + "version": "5.2.5", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "xz", + "srpm_nevra": "xz-5.2.5-8.el9_0.src", + "release": "8.el9_0" + }, + { + "name": "yajl", + "version": "2.1.0", + "kind": "binary", + "_repositoryhint": "repoid=rhel-9-appstream-rpms", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "yajl", + "srpm_nevra": "yajl-2.1.0-22.el9.src", + "release": "22.el9" + }, + { + "name": "yum", + "version": "4.14.0", + "kind": "binary", + "_repositoryhint": "", + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "srpm_name": "dnf", + "srpm_nevra": "dnf-4.14.0-17.el9.src", + "release": "17.el9" + }, + { + "name": "zlib", + "version": "1.2.11", + "kind": "binary", + "_repositoryhint": "", + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "srpm_name": "zlib", + "srpm_nevra": "zlib-1.2.11-40.el9.src", + "release": "40.el9" + } + ] +} diff --git a/rhel/testdata/nodejs.rpm-manifest.json b/rhel/testdata/nodejs.rpm-manifest.json new file mode 100644 index 000000000..845a00384 --- /dev/null +++ b/rhel/testdata/nodejs.rpm-manifest.json @@ -0,0 +1,3019 @@ +{ + "rpms": [ + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "acl", + "release": "3.el9", + "srpm_name": "acl", + "srpm_nevra": "acl-0:2.3.1-3.el9.src", + "version": "2.3.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "alternatives", + "release": "2.el9", + "srpm_name": "chkconfig", + "srpm_nevra": "chkconfig-0:1.20-2.el9.src", + "version": "1.20", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "audit-libs", + "release": "103.el9", + "srpm_name": "audit", + "srpm_nevra": "audit-0:3.0.7-103.el9.src", + "version": "3.0.7", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "basesystem", + "release": "13.el9", + "srpm_name": "basesystem", + "srpm_nevra": "basesystem-0:11-13.el9.src", + "version": "11", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "bash", + "release": "6.el9", + "srpm_name": "bash", + "srpm_nevra": "bash-0:5.1.8-6.el9.src", + "version": "5.1.8", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "binutils", + "release": "37.el9", + "srpm_name": "binutils", + "srpm_nevra": "binutils-0:2.35.2-37.el9.src", + "version": "2.35.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "binutils-gold", + "release": "37.el9", + "srpm_name": "binutils", + "srpm_nevra": "binutils-0:2.35.2-37.el9.src", + "version": "2.35.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "bsdtar", + "release": "4.el9", + "srpm_name": "libarchive", + "srpm_nevra": "libarchive-0:3.5.3-4.el9.src", + "version": "3.5.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "bzip2-libs", + "release": "8.el9", + "srpm_name": "bzip2", + "srpm_nevra": "bzip2-0:1.0.8-8.el9.src", + "version": "1.0.8", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "ca-certificates", + "release": "90.2.el9_0", + "srpm_name": "ca-certificates", + "srpm_nevra": "ca-certificates-0:2022.2.54-90.2.el9_0.src", + "version": "2022.2.54", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cmake", + "release": "8.el9", + "srpm_name": "cmake", + "srpm_nevra": "cmake-0:3.20.2-8.el9.src", + "version": "3.20.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "cmake-data", + "release": "8.el9", + "srpm_name": "cmake", + "srpm_nevra": "cmake-0:3.20.2-8.el9.src", + "version": "3.20.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cmake-filesystem", + "release": "8.el9", + "srpm_name": "cmake", + "srpm_nevra": "cmake-0:3.20.2-8.el9.src", + "version": "3.20.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "cmake-rpm-macros", + "release": "8.el9", + "srpm_name": "cmake", + "srpm_nevra": "cmake-0:3.20.2-8.el9.src", + "version": "3.20.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "coreutils-single", + "release": "34.el9", + "srpm_name": "coreutils", + "srpm_nevra": "coreutils-0:8.32-34.el9.src", + "version": "8.32", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cpp", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cracklib", + "release": "27.el9", + "srpm_name": "cracklib", + "srpm_nevra": "cracklib-0:2.9.6-27.el9.src", + "version": "2.9.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cracklib-dicts", + "release": "27.el9", + "srpm_name": "cracklib", + "srpm_nevra": "cracklib-0:2.9.6-27.el9.src", + "version": "2.9.6", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "crypto-policies", + "release": "1.git9a18988.el9", + "srpm_name": "crypto-policies", + "srpm_nevra": "crypto-policies-0:20221215-1.git9a18988.el9.src", + "version": "20221215", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "crypto-policies-scripts", + "release": "1.git9a18988.el9", + "srpm_name": "crypto-policies", + "srpm_nevra": "crypto-policies-0:20221215-1.git9a18988.el9.src", + "version": "20221215", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "curl-minimal", + "release": "23.el9_2.1", + "srpm_name": "curl", + "srpm_nevra": "curl-0:7.76.1-23.el9_2.1.src", + "version": "7.76.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "cyrus-sasl-lib", + "release": "21.el9", + "srpm_name": "cyrus-sasl", + "srpm_nevra": "cyrus-sasl-0:2.1.27-21.el9.src", + "version": "2.1.27", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "dbus", + "release": "7.el9_1", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1:1.12.20-7.el9_1.src", + "version": "1.12.20", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "dbus-broker", + "release": "7.el9", + "srpm_name": "dbus-broker", + "srpm_nevra": "dbus-broker-0:28-7.el9.src", + "version": "28", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "dbus-common", + "release": "7.el9_1", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1:1.12.20-7.el9_1.src", + "version": "1.12.20", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "dbus-libs", + "release": "7.el9_1", + "srpm_name": "dbus", + "srpm_nevra": "dbus-1:1.12.20-7.el9_1.src", + "version": "1.12.20", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "dejavu-sans-fonts", + "release": "18.el9", + "srpm_name": "dejavu-fonts", + "srpm_nevra": "dejavu-fonts-0:2.37-18.el9.src", + "version": "2.37", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "dmidecode", + "release": "7.el9", + "srpm_name": "dmidecode", + "srpm_nevra": "dmidecode-1:3.3-7.el9.src", + "version": "3.3", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "dnf", + "release": "5.el9_2", + "srpm_name": "dnf", + "srpm_nevra": "dnf-0:4.14.0-5.el9_2.src", + "version": "4.14.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "dnf-data", + "release": "5.el9_2", + "srpm_name": "dnf", + "srpm_nevra": "dnf-0:4.14.0-5.el9_2.src", + "version": "4.14.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "elfutils-debuginfod-client", + "release": "3.el9", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0:0.188-3.el9.src", + "version": "0.188", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "elfutils-default-yama-scope", + "release": "3.el9", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0:0.188-3.el9.src", + "version": "0.188", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "elfutils-libelf", + "release": "3.el9", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0:0.188-3.el9.src", + "version": "0.188", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "elfutils-libs", + "release": "3.el9", + "srpm_name": "elfutils", + "srpm_nevra": "elfutils-0:0.188-3.el9.src", + "version": "0.188", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "emacs-filesystem", + "release": "8.el9", + "srpm_name": "emacs", + "srpm_nevra": "emacs-27.2-8.el9_2.1.src", + "version": "27.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "environment-modules", + "release": "2.el9", + "srpm_name": "environment-modules", + "srpm_nevra": "environment-modules-0:5.0.1-2.el9.src", + "version": "5.0.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "expat", + "release": "1.el9", + "srpm_name": "expat", + "srpm_nevra": "expat-0:2.5.0-1.el9.src", + "version": "2.5.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "file-libs", + "release": "12.el9", + "srpm_name": "file", + "srpm_nevra": "file-0:5.39-12.el9.src", + "version": "5.39", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "filesystem", + "release": "2.el9", + "srpm_name": "filesystem", + "srpm_nevra": "filesystem-0:3.16-2.el9.src", + "version": "3.16", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "findutils", + "release": "5.el9", + "srpm_name": "findutils", + "srpm_nevra": "findutils-1:4.8.0-5.el9.src", + "version": "4.8.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "fonts-filesystem", + "release": "7.el9.1", + "srpm_name": "fonts-rpm-macros", + "srpm_nevra": "fonts-rpm-macros-1:2.0.5-7.el9.1.src", + "version": "2.0.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gawk", + "release": "6.el9", + "srpm_name": "gawk", + "srpm_nevra": "gawk-0:5.1.0-6.el9.src", + "version": "5.1.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gcc", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gcc-c++", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gdb-gdbserver", + "release": "10.el9", + "srpm_name": "gdb", + "srpm_nevra": "gdb-0:10.2-10.el9.src", + "version": "10.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gdbm-libs", + "release": "4.el9", + "srpm_name": "gdbm", + "srpm_nevra": "gdbm-1:1.19-4.el9.src", + "version": "1.19", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gettext", + "release": "7.el9", + "srpm_name": "gettext", + "srpm_nevra": "gettext-0:0.21-7.el9.src", + "version": "0.21", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gettext-libs", + "release": "7.el9", + "srpm_name": "gettext", + "srpm_nevra": "gettext-0:0.21-7.el9.src", + "version": "0.21", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "git", + "release": "1.el9_2", + "srpm_name": "git", + "srpm_nevra": "git-0:2.39.3-1.el9_2.src", + "version": "2.39.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "git-core", + "release": "1.el9_2", + "srpm_name": "git", + "srpm_nevra": "git-0:2.39.3-1.el9_2.src", + "version": "2.39.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "git-core-doc", + "release": "1.el9_2", + "srpm_name": "git", + "srpm_nevra": "git-0:2.39.3-1.el9_2.src", + "version": "2.39.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glib2", + "release": "6.el9", + "srpm_name": "glib2", + "srpm_nevra": "glib2-0:2.68.4-6.el9.src", + "version": "2.68.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-common", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-devel", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-headers", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-langpack-en", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-locale-source", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "glibc-minimal-langpack", + "release": "60.el9", + "srpm_name": "glibc", + "srpm_nevra": "glibc-0:2.34-60.el9.src", + "version": "2.34", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gmp", + "release": "10.el9", + "srpm_name": "gmp", + "srpm_nevra": "gmp-1:6.2.0-10.el9.src", + "version": "6.2.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gnupg2", + "release": "2.el9_0", + "srpm_name": "gnupg2", + "srpm_nevra": "gnupg2-0:2.3.3-2.el9_0.src", + "version": "2.3.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gnutls", + "release": "20.el9_2", + "srpm_name": "gnutls", + "srpm_nevra": "gnutls-0:3.7.6-20.el9_2.src", + "version": "3.7.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gobject-introspection", + "release": "11.el9", + "srpm_name": "gobject-introspection", + "srpm_nevra": "gobject-introspection-0:1.68.0-11.el9.src", + "version": "1.68.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gpgme", + "release": "6.el9", + "srpm_name": "gpgme", + "srpm_nevra": "gpgme-0:1.15.1-6.el9.src", + "version": "1.15.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "grep", + "release": "5.el9", + "srpm_name": "grep", + "srpm_nevra": "grep-0:3.6-5.el9.src", + "version": "3.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "groff-base", + "release": "10.el9", + "srpm_name": "groff", + "srpm_nevra": "groff-0:1.22.4-10.el9.src", + "version": "1.22.4", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "gzip", + "release": "1.el9", + "srpm_name": "gzip", + "srpm_nevra": "gzip-0:1.12-1.el9.src", + "version": "1.12", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "ima-evm-utils", + "release": "4.el9", + "srpm_name": "ima-evm-utils", + "srpm_nevra": "ima-evm-utils-0:1.4-4.el9.src", + "version": "1.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "json-c", + "release": "11.el9", + "srpm_name": "json-c", + "srpm_nevra": "json-c-0:0.14-11.el9.src", + "version": "0.14", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "json-glib", + "release": "1.el9", + "srpm_name": "json-glib", + "srpm_nevra": "json-glib-0:1.6.6-1.el9.src", + "version": "1.6.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "kernel-headers", + "release": "284.18.1.el9_2", + "srpm_name": "kernel", + "srpm_nevra": "kernel-0:5.14.0-284.18.1.el9_2.src", + "version": "5.14.0", + "_repositoryhint": "repoid=RHEL-9.2.0-updates-20230615.3-AppStream" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "keyutils-libs", + "release": "1.el9", + "srpm_name": "keyutils", + "srpm_nevra": "keyutils-0:1.6.3-1.el9.src", + "version": "1.6.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "kmod-libs", + "release": "7.el9", + "srpm_name": "kmod", + "srpm_nevra": "kmod-0:28-7.el9.src", + "version": "28", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "krb5-libs", + "release": "9.el9_2", + "srpm_name": "krb5", + "srpm_nevra": "krb5-0:1.20.1-9.el9_2.src", + "version": "1.20.1", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "langpacks-core-en", + "release": "16.el9", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-0:3.0-16.el9.src", + "version": "3.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "langpacks-core-font-en", + "release": "16.el9", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-0:3.0-16.el9.src", + "version": "3.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "langpacks-en", + "release": "16.el9", + "srpm_name": "langpacks", + "srpm_nevra": "langpacks-0:3.0-16.el9.src", + "version": "3.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "less", + "release": "2.el9_2", + "srpm_name": "less", + "srpm_nevra": "less-0:590-2.el9_2.src", + "version": "590", + "_repositoryhint": "repoid=RHEL-9.2.0-updates-20230615.3-BaseOS" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libacl", + "release": "3.el9", + "srpm_name": "acl", + "srpm_nevra": "acl-0:2.3.1-3.el9.src", + "version": "2.3.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libarchive", + "release": "4.el9", + "srpm_name": "libarchive", + "srpm_nevra": "libarchive-0:3.5.3-4.el9.src", + "version": "3.5.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libassuan", + "release": "3.el9", + "srpm_name": "libassuan", + "srpm_nevra": "libassuan-0:2.5.5-3.el9.src", + "version": "2.5.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libattr", + "release": "3.el9", + "srpm_name": "attr", + "srpm_nevra": "attr-0:2.5.1-3.el9.src", + "version": "2.5.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libblkid", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libbrotli", + "release": "6.el9", + "srpm_name": "brotli", + "srpm_nevra": "brotli-0:1.0.9-6.el9.src", + "version": "1.0.9", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcap", + "release": "8.el9", + "srpm_name": "libcap", + "srpm_nevra": "libcap-0:2.48-8.el9.src", + "version": "2.48", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcap-ng", + "release": "7.el9", + "srpm_name": "libcap-ng", + "srpm_nevra": "libcap-ng-0:0.8.2-7.el9.src", + "version": "0.8.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcbor", + "release": "5.el9", + "srpm_name": "libcbor", + "srpm_nevra": "libcbor-0:0.7.0-5.el9.src", + "version": "0.7.0", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcom_err", + "release": "3.el9", + "srpm_name": "e2fsprogs", + "srpm_nevra": "e2fsprogs-0:1.46.5-3.el9.src", + "version": "1.46.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcomps", + "release": "1.el9", + "srpm_name": "libcomps", + "srpm_nevra": "libcomps-0:0.1.18-1.el9.src", + "version": "0.1.18", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libcurl-minimal", + "release": "23.el9_2.1", + "srpm_name": "curl", + "srpm_nevra": "curl-0:7.76.1-23.el9_2.1.src", + "version": "7.76.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libdb", + "release": "53.el9", + "srpm_name": "libdb", + "srpm_nevra": "libdb-0:5.3.28-53.el9.src", + "version": "5.3.28", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libdnf", + "release": "3.el9_2", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0:0.69.0-3.el9_2.src", + "version": "0.69.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libdnf-plugin-subscription-manager", + "release": "1.el9_2", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-0:1.29.33.1-1.el9_2.src", + "version": "1.29.33.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libeconf", + "release": "2.el9", + "srpm_name": "libeconf", + "srpm_nevra": "libeconf-0:0.4.1-2.el9.src", + "version": "0.4.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libedit", + "release": "37.20210216cvs.el9", + "srpm_name": "libedit", + "srpm_nevra": "libedit-0:3.1-37.20210216cvs.el9.src", + "version": "3.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libevent", + "release": "6.el9", + "srpm_name": "libevent", + "srpm_nevra": "libevent-0:2.1.12-6.el9.src", + "version": "2.1.12", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libfdisk", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libffi", + "release": "7.el9", + "srpm_name": "libffi", + "srpm_nevra": "libffi-0:3.4.2-7.el9.src", + "version": "3.4.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libfido2", + "release": "7.el9", + "srpm_name": "libfido2", + "srpm_nevra": "libfido2-0:1.6.0-7.el9.src", + "version": "1.6.0", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libgcc", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libgcrypt", + "release": "10.el9_2", + "srpm_name": "libgcrypt", + "srpm_nevra": "libgcrypt-0:1.10.0-10.el9_2.src", + "version": "1.10.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libgomp", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libgpg-error", + "release": "5.el9", + "srpm_name": "libgpg-error", + "srpm_nevra": "libgpg-error-0:1.42-5.el9.src", + "version": "1.42", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libidn2", + "release": "7.el9", + "srpm_name": "libidn2", + "srpm_nevra": "libidn2-0:2.3.0-7.el9.src", + "version": "2.3.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libksba", + "release": "6.el9_1", + "srpm_name": "libksba", + "srpm_nevra": "libksba-0:1.5.1-6.el9_1.src", + "version": "1.5.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libmodulemd", + "release": "2.el9", + "srpm_name": "libmodulemd", + "srpm_nevra": "libmodulemd-0:2.13.0-2.el9.src", + "version": "2.13.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libmount", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libmpc", + "release": "4.el9", + "srpm_name": "libmpc", + "srpm_nevra": "libmpc-0:1.2.1-4.el9.src", + "version": "1.2.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libnghttp2", + "release": "5.el9", + "srpm_name": "nghttp2", + "srpm_nevra": "nghttp2-0:1.43.0-5.el9.src", + "version": "1.43.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libnl3", + "release": "1.el9", + "srpm_name": "libnl3", + "srpm_nevra": "libnl3-0:3.7.0-1.el9.src", + "version": "3.7.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libpipeline", + "release": "4.el9", + "srpm_name": "libpipeline", + "srpm_nevra": "libpipeline-0:1.5.3-4.el9.src", + "version": "1.5.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libpkgconf", + "release": "10.el9", + "srpm_name": "pkgconf", + "srpm_nevra": "pkgconf-0:1.7.3-10.el9.src", + "version": "1.7.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libpwquality", + "release": "8.el9", + "srpm_name": "libpwquality", + "srpm_nevra": "libpwquality-0:1.4.4-8.el9.src", + "version": "1.4.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "librepo", + "release": "1.el9", + "srpm_name": "librepo", + "srpm_nevra": "librepo-0:1.14.5-1.el9.src", + "version": "1.14.5", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "libreport-filesystem", + "release": "6.el9", + "srpm_name": "libreport", + "srpm_nevra": "libreport-0:2.15.2-6.el9.src", + "version": "2.15.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "librhsm", + "release": "7.el9", + "srpm_name": "librhsm", + "srpm_nevra": "librhsm-0:0.0.3-7.el9.src", + "version": "0.0.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libseccomp", + "release": "2.el9", + "srpm_name": "libseccomp", + "srpm_nevra": "libseccomp-0:2.5.2-2.el9.src", + "version": "2.5.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libselinux", + "release": "1.el9", + "srpm_name": "libselinux", + "srpm_nevra": "libselinux-0:3.5-1.el9.src", + "version": "3.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libsemanage", + "release": "1.el9", + "srpm_name": "libsemanage", + "srpm_nevra": "libsemanage-0:3.5-1.el9.src", + "version": "3.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libsepol", + "release": "1.el9", + "srpm_name": "libsepol", + "srpm_nevra": "libsepol-0:3.5-1.el9.src", + "version": "3.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libsigsegv", + "release": "4.el9", + "srpm_name": "libsigsegv", + "srpm_nevra": "libsigsegv-0:2.13-4.el9.src", + "version": "2.13", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libsmartcols", + "release": "11.el9", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libsolv", + "release": "4.el9", + "srpm_name": "libsolv", + "srpm_nevra": "libsolv-0:0.7.22-4.el9.src", + "version": "0.7.22", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libstdc++", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libstdc++-devel", + "release": "4.3.el9", + "srpm_name": "gcc", + "srpm_nevra": "gcc-0:11.3.1-4.3.el9.src", + "version": "11.3.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libtasn1", + "release": "8.el9_1", + "srpm_name": "libtasn1", + "srpm_nevra": "libtasn1-0:4.16.0-8.el9_1.src", + "version": "4.16.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libunistring", + "release": "15.el9", + "srpm_name": "libunistring", + "srpm_nevra": "libunistring-0:0.9.10-15.el9.src", + "version": "0.9.10", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libuser", + "release": "12.el9", + "srpm_name": "libuser", + "srpm_nevra": "libuser-0:0.63-12.el9.src", + "version": "0.63", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libutempter", + "release": "6.el9", + "srpm_name": "libutempter", + "srpm_nevra": "libutempter-0:1.2.1-6.el9.src", + "version": "1.2.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libuuid", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libuv", + "release": "1.el9", + "srpm_name": "libuv", + "srpm_nevra": "libuv-1:1.42.0-1.el9.src", + "version": "1.42.0", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libverto", + "release": "3.el9", + "srpm_name": "libverto", + "srpm_nevra": "libverto-0:0.3.2-3.el9.src", + "version": "0.3.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libxcrypt", + "release": "3.el9", + "srpm_name": "libxcrypt", + "srpm_nevra": "libxcrypt-0:4.4.18-3.el9.src", + "version": "4.4.18", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libxcrypt-devel", + "release": "3.el9", + "srpm_name": "libxcrypt", + "srpm_nevra": "libxcrypt-0:4.4.18-3.el9.src", + "version": "4.4.18", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libxml2", + "release": "3.el9_1", + "srpm_name": "libxml2", + "srpm_nevra": "libxml2-0:2.9.13-3.el9_1.src", + "version": "2.9.13", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libyaml", + "release": "7.el9", + "srpm_name": "libyaml", + "srpm_nevra": "libyaml-0:0.2.5-7.el9.src", + "version": "0.2.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "libzstd", + "release": "2.el9", + "srpm_name": "zstd", + "srpm_nevra": "zstd-0:1.5.1-2.el9.src", + "version": "1.5.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "lua-libs", + "release": "3.el9", + "srpm_name": "lua", + "srpm_nevra": "lua-0:5.4.4-3.el9.src", + "version": "5.4.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "lz4-libs", + "release": "5.el9", + "srpm_name": "lz4", + "srpm_nevra": "lz4-0:1.9.3-5.el9.src", + "version": "1.9.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "make", + "release": "7.el9", + "srpm_name": "make", + "srpm_nevra": "make-1:4.3-7.el9.src", + "version": "4.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "man-db", + "release": "7.el9", + "srpm_name": "man-db", + "srpm_nevra": "man-db-0:2.9.3-7.el9.src", + "version": "2.9.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "mpfr", + "release": "7.el9", + "srpm_name": "mpfr", + "srpm_nevra": "mpfr-0:4.1.0-7.el9.src", + "version": "4.1.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "ncurses", + "release": "8.20210508.el9", + "srpm_name": "ncurses", + "srpm_nevra": "ncurses-0:6.2-8.20210508.el9.src", + "version": "6.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "ncurses-base", + "release": "8.20210508.el9", + "srpm_name": "ncurses", + "srpm_nevra": "ncurses-0:6.2-8.20210508.el9.src", + "version": "6.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "ncurses-libs", + "release": "8.20210508.el9", + "srpm_name": "ncurses", + "srpm_nevra": "ncurses-0:6.2-8.20210508.el9.src", + "version": "6.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "nettle", + "release": "3.el9_0", + "srpm_name": "nettle", + "srpm_nevra": "nettle-0:3.8-3.el9_0.src", + "version": "3.8", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "nodejs", + "release": "3.module+el9.2.0.z+18964+42696395", + "srpm_name": "nodejs", + "srpm_nevra": "nodejs-18.14.2-3.module+el9.2.0.z+18964+42696395.src", + "module": "nodejs:18", + "version": "18.14.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "nodejs-docs", + "release": "3.module+el9.2.0.z+18964+42696395", + "srpm_name": "nodejs", + "srpm_nevra": "nodejs-18.14.2-3.module+el9.2.0.z+18964+42696395.src", + "module": "nodejs:18", + "version": "18.14.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "nodejs-full-i18n", + "release": "3.module+el9.2.0.z+18964+42696395", + "srpm_name": "nodejs", + "srpm_nevra": "nodejs-18.14.2-3.module+el9.2.0.z+18964+42696395.src", + "module": "nodejs:18", + "version": "18.14.2", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "nodejs-nodemon", + "release": "2.module+el9.2.0.z+18497+a402347c", + "srpm_name": "nodejs-nodemon", + "srpm_nevra": "nodejs-nodemon-0:2.0.20-2.module+el9.2.0.z+18497+a402347c.src", + "module": "nodejs:18", + "version": "2.0.20", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "npm", + "release": "1.18.14.2.3.module+el9.2.0.z+18964+42696395", + "srpm_name": "nodejs", + "srpm_nevra": "nodejs-18.14.2-3.module+el9.2.0.z+18964+42696395.src", + "module": "nodejs:18", + "version": "1:9.5.0", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "npth", + "release": "8.el9", + "srpm_name": "npth", + "srpm_nevra": "npth-0:1.6-8.el9.src", + "version": "1.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "nss_wrapper", + "release": "1.el9", + "srpm_name": "nss_wrapper", + "srpm_nevra": "nss_wrapper-0:1.1.13-1.el9.src", + "version": "1.1.13", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "nss_wrapper-libs", + "release": "1.el9", + "srpm_name": "nss_wrapper", + "srpm_nevra": "nss_wrapper-0:1.1.13-1.el9.src", + "version": "1.1.13", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openldap", + "release": "3.el9", + "srpm_name": "openldap", + "srpm_nevra": "openldap-0:2.6.2-3.el9.src", + "version": "2.6.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openldap-compat", + "release": "3.el9", + "srpm_name": "openldap", + "srpm_nevra": "openldap-0:2.6.2-3.el9.src", + "version": "2.6.2", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openssh", + "release": "29.el9_2", + "srpm_name": "openssh", + "srpm_nevra": "openssh-0:8.7p1-29.el9_2.src", + "version": "8.7p1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openssh-clients", + "release": "29.el9_2", + "srpm_name": "openssh", + "srpm_nevra": "openssh-0:8.7p1-29.el9_2.src", + "version": "8.7p1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openssl", + "release": "16.el9_2", + "srpm_name": "openssl", + "srpm_nevra": "openssl-3.0.7-16.el9_2.src", + "version": "3.0.7", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openssl-devel", + "release": "16.el9_2", + "srpm_name": "openssl", + "srpm_nevra": "openssl-3.0.7-16.el9_2.src", + "version": "3.0.7", + "_repositoryhint": "repoid=RHEL-9.2.0-updates-20230615.3-AppStream" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "openssl-libs", + "release": "16.el9_2", + "srpm_name": "openssl", + "srpm_nevra": "openssl-3.0.7-16.el9_2.src", + "version": "3.0.7", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "p11-kit", + "release": "2.el9", + "srpm_name": "p11-kit", + "srpm_nevra": "p11-kit-0:0.24.1-2.el9.src", + "version": "0.24.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "p11-kit-trust", + "release": "2.el9", + "srpm_name": "p11-kit", + "srpm_nevra": "p11-kit-0:0.24.1-2.el9.src", + "version": "0.24.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "pam", + "release": "14.el9", + "srpm_name": "pam", + "srpm_nevra": "pam-0:1.5.1-14.el9.src", + "version": "1.5.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "passwd", + "release": "12.el9", + "srpm_name": "passwd", + "srpm_nevra": "passwd-0:0.80-12.el9.src", + "version": "0.80", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "pcre", + "release": "3.el9.3", + "srpm_name": "pcre", + "srpm_nevra": "pcre-0:8.44-3.el9.3.src", + "version": "8.44", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "pcre2", + "release": "2.el9", + "srpm_name": "pcre2", + "srpm_nevra": "pcre2-0:10.40-2.el9.src", + "version": "10.40", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "pcre2-syntax", + "release": "2.el9", + "srpm_name": "pcre2", + "srpm_nevra": "pcre2-0:10.40-2.el9.src", + "version": "10.40", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-AutoLoader", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "5.74", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-B", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.80", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Carp", + "release": "460.el9", + "srpm_name": "perl-Carp", + "srpm_nevra": "perl-Carp-0:1.50-460.el9.src", + "version": "1.50", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Class-Struct", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "0.66", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Data-Dumper", + "release": "462.el9", + "srpm_name": "perl-Data-Dumper", + "srpm_nevra": "perl-Data-Dumper-0:2.174-462.el9.src", + "version": "2.174", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Digest", + "release": "4.el9", + "srpm_name": "perl-Digest", + "srpm_nevra": "perl-Digest-0:1.19-4.el9.src", + "version": "1.19", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Digest-MD5", + "release": "4.el9", + "srpm_name": "perl-Digest-MD5", + "srpm_nevra": "perl-Digest-MD5-0:2.58-4.el9.src", + "version": "2.58", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-DynaLoader", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.47", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Encode", + "release": "462.el9", + "srpm_name": "perl-Encode", + "srpm_nevra": "perl-Encode-4:3.08-462.el9.src", + "version": "3.08", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Errno", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.30", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Error", + "release": "7.el9", + "srpm_name": "perl-Error", + "srpm_nevra": "perl-Error-1:0.17029-7.el9.src", + "version": "0.17029", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Exporter", + "release": "461.el9", + "srpm_name": "perl-Exporter", + "srpm_nevra": "perl-Exporter-0:5.74-461.el9.src", + "version": "5.74", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Fcntl", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.13", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-File-Basename", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "2.85", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-File-Find", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.37", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-File-Path", + "release": "4.el9", + "srpm_name": "perl-File-Path", + "srpm_nevra": "perl-File-Path-0:2.18-4.el9.src", + "version": "2.18", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-File-Temp", + "release": "4.el9", + "srpm_name": "perl-File-Temp", + "srpm_nevra": "perl-File-Temp-1:0.231.100-4.el9.src", + "version": "0.231.100", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-File-stat", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.09", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-FileHandle", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "2.03", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Getopt-Long", + "release": "4.el9", + "srpm_name": "perl-Getopt-Long", + "srpm_nevra": "perl-Getopt-Long-1:2.52-4.el9.src", + "version": "2.52", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Getopt-Std", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.12", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Git", + "release": "1.el9_2", + "srpm_name": "git", + "srpm_nevra": "git-0:2.39.3-1.el9_2.src", + "version": "2.39.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-HTTP-Tiny", + "release": "460.el9", + "srpm_name": "perl-HTTP-Tiny", + "srpm_nevra": "perl-HTTP-Tiny-0:0.076-460.el9.src", + "version": "0.076", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-IO", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.43", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-IO-Socket-IP", + "release": "5.el9", + "srpm_name": "perl-IO-Socket-IP", + "srpm_nevra": "perl-IO-Socket-IP-0:0.41-5.el9.src", + "version": "0.41", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-IO-Socket-SSL", + "release": "1.el9", + "srpm_name": "perl-IO-Socket-SSL", + "srpm_nevra": "perl-IO-Socket-SSL-0:2.073-1.el9.src", + "version": "2.073", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-IPC-Open3", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.21", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-MIME-Base64", + "release": "4.el9", + "srpm_name": "perl-MIME-Base64", + "srpm_nevra": "perl-MIME-Base64-0:3.16-4.el9.src", + "version": "3.16", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Mozilla-CA", + "release": "6.el9", + "srpm_name": "perl-Mozilla-CA", + "srpm_nevra": "perl-Mozilla-CA-0:20200520-6.el9.src", + "version": "20200520", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-NDBM_File", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.15", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Net-SSLeay", + "release": "2.el9", + "srpm_name": "perl-Net-SSLeay", + "srpm_nevra": "perl-Net-SSLeay-0:1.92-2.el9.src", + "version": "1.92", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-POSIX", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.94", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-PathTools", + "release": "461.el9", + "srpm_name": "perl-PathTools", + "srpm_nevra": "perl-PathTools-0:3.78-461.el9.src", + "version": "3.78", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Pod-Escapes", + "release": "460.el9", + "srpm_name": "perl-Pod-Escapes", + "srpm_nevra": "perl-Pod-Escapes-1:1.07-460.el9.src", + "version": "1.07", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Pod-Perldoc", + "release": "461.el9", + "srpm_name": "perl-Pod-Perldoc", + "srpm_nevra": "perl-Pod-Perldoc-0:3.28.01-461.el9.src", + "version": "3.28.01", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Pod-Simple", + "release": "4.el9", + "srpm_name": "perl-Pod-Simple", + "srpm_nevra": "perl-Pod-Simple-1:3.42-4.el9.src", + "version": "3.42", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Pod-Usage", + "release": "4.el9", + "srpm_name": "perl-Pod-Usage", + "srpm_nevra": "perl-Pod-Usage-4:2.01-4.el9.src", + "version": "2.01", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Scalar-List-Utils", + "release": "461.el9", + "srpm_name": "perl-Scalar-List-Utils", + "srpm_nevra": "perl-Scalar-List-Utils-4:1.56-461.el9.src", + "version": "1.56", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-SelectSaver", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.02", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Socket", + "release": "4.el9", + "srpm_name": "perl-Socket", + "srpm_nevra": "perl-Socket-4:2.031-4.el9.src", + "version": "2.031", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-Storable", + "release": "460.el9", + "srpm_name": "perl-Storable", + "srpm_nevra": "perl-Storable-1:3.21-460.el9.src", + "version": "3.21", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Symbol", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.08", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Term-ANSIColor", + "release": "461.el9", + "srpm_name": "perl-Term-ANSIColor", + "srpm_nevra": "perl-Term-ANSIColor-0:5.01-461.el9.src", + "version": "5.01", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Term-Cap", + "release": "460.el9", + "srpm_name": "perl-Term-Cap", + "srpm_nevra": "perl-Term-Cap-0:1.17-460.el9.src", + "version": "1.17", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-TermReadKey", + "release": "11.el9", + "srpm_name": "perl-TermReadKey", + "srpm_nevra": "perl-TermReadKey-0:2.38-11.el9.src", + "version": "2.38", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Text-ParseWords", + "release": "460.el9", + "srpm_name": "perl-Text-ParseWords", + "srpm_nevra": "perl-Text-ParseWords-0:3.30-460.el9.src", + "version": "3.30", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Text-Tabs+Wrap", + "release": "460.el9", + "srpm_name": "perl-Text-Tabs+Wrap", + "srpm_nevra": "perl-Text-Tabs+Wrap-0:2013.0523-460.el9.src", + "version": "2013.0523", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-Time-Local", + "release": "7.el9", + "srpm_name": "perl-Time-Local", + "srpm_nevra": "perl-Time-Local-2:1.300-7.el9.src", + "version": "1.300", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-URI", + "release": "3.el9", + "srpm_name": "perl-URI", + "srpm_nevra": "perl-URI-0:5.09-3.el9.src", + "version": "5.09", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-base", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "2.27", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-constant", + "release": "461.el9", + "srpm_name": "perl-constant", + "srpm_nevra": "perl-constant-0:1.33-461.el9.src", + "version": "1.33", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-if", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "0.60.800", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-interpreter", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "5.32.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-lib", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "0.65", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-libnet", + "release": "4.el9", + "srpm_name": "perl-libnet", + "srpm_nevra": "perl-libnet-0:3.13-4.el9.src", + "version": "3.13", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-libs", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "5.32.1", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "perl-mro", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.23", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-overload", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.31", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-overloading", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "0.02", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-parent", + "release": "460.el9", + "srpm_name": "perl-parent", + "srpm_nevra": "perl-parent-1:0.238-460.el9.src", + "version": "0.238", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-podlators", + "release": "460.el9", + "srpm_name": "perl-podlators", + "srpm_nevra": "perl-podlators-1:4.14-460.el9.src", + "version": "4.14", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-subs", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.03", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "perl-vars", + "release": "480.el9", + "srpm_name": "perl", + "srpm_nevra": "perl-4:5.32.1-480.el9.src", + "version": "1.05", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "pkgconf", + "release": "10.el9", + "srpm_name": "pkgconf", + "srpm_nevra": "pkgconf-0:1.7.3-10.el9.src", + "version": "1.7.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "pkgconf-m4", + "release": "10.el9", + "srpm_name": "pkgconf", + "srpm_nevra": "pkgconf-0:1.7.3-10.el9.src", + "version": "1.7.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "pkgconf-pkg-config", + "release": "10.el9", + "srpm_name": "pkgconf", + "srpm_nevra": "pkgconf-0:1.7.3-10.el9.src", + "version": "1.7.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "popt", + "release": "8.el9", + "srpm_name": "popt", + "srpm_nevra": "popt-0:1.18-8.el9.src", + "version": "1.18", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "procps-ng", + "release": "11.el9", + "srpm_name": "procps-ng", + "srpm_nevra": "procps-ng-0:3.3.17-11.el9.src", + "version": "3.3.17", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3", + "release": "1.el9_2.1", + "srpm_name": "python3.9", + "srpm_nevra": "python3.9-0:3.9.16-1.el9_2.1.src", + "version": "3.9.16", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-chardet", + "release": "5.el9", + "srpm_name": "python-chardet", + "srpm_nevra": "python-chardet-0:4.0.0-5.el9.src", + "version": "4.0.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-cloud-what", + "release": "1.el9_2", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-0:1.29.33.1-1.el9_2.src", + "version": "1.29.33.1", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-dateutil", + "release": "6.el9", + "srpm_name": "python-dateutil", + "srpm_nevra": "python-dateutil-1:2.8.1-6.el9.src", + "version": "2.8.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-dbus", + "release": "2.el9", + "srpm_name": "dbus-python", + "srpm_nevra": "dbus-python-0:1.2.18-2.el9.src", + "version": "1.2.18", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-decorator", + "release": "6.el9", + "srpm_name": "python-decorator", + "srpm_nevra": "python-decorator-0:4.4.2-6.el9.src", + "version": "4.4.2", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-dnf", + "release": "5.el9_2", + "srpm_name": "dnf", + "srpm_nevra": "dnf-0:4.14.0-5.el9_2.src", + "version": "4.14.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-dnf-plugins-core", + "release": "5.el9_2", + "srpm_name": "dnf-plugins-core", + "srpm_nevra": "dnf-plugins-core-0:4.3.0-5.el9_2.src", + "version": "4.3.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-ethtool", + "release": "2.el9", + "srpm_name": "python-ethtool", + "srpm_nevra": "python-ethtool-0:0.15-2.el9.src", + "version": "0.15", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-gobject-base", + "release": "6.el9", + "srpm_name": "pygobject3", + "srpm_nevra": "pygobject3-0:3.40.1-6.el9.src", + "version": "3.40.1", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-gobject-base-noarch", + "release": "6.el9", + "srpm_name": "pygobject3", + "srpm_nevra": "pygobject3-0:3.40.1-6.el9.src", + "version": "3.40.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-gpg", + "release": "6.el9", + "srpm_name": "gpgme", + "srpm_nevra": "gpgme-0:1.15.1-6.el9.src", + "version": "1.15.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-hawkey", + "release": "3.el9_2", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0:0.69.0-3.el9_2.src", + "version": "0.69.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-idna", + "release": "7.el9", + "srpm_name": "python-idna", + "srpm_nevra": "python-idna-0:2.10-7.el9.src", + "version": "2.10", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-iniparse", + "release": "45.el9", + "srpm_name": "python-iniparse", + "srpm_nevra": "python-iniparse-0:0.4-45.el9.src", + "version": "0.4", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-inotify", + "release": "25.el9", + "srpm_name": "python-inotify", + "srpm_nevra": "python-inotify-0:0.9.6-25.el9.src", + "version": "0.9.6", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-libcomps", + "release": "1.el9", + "srpm_name": "libcomps", + "srpm_nevra": "libcomps-0:0.1.18-1.el9.src", + "version": "0.1.18", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-libdnf", + "release": "3.el9_2", + "srpm_name": "libdnf", + "srpm_nevra": "libdnf-0:0.69.0-3.el9_2.src", + "version": "0.69.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-librepo", + "release": "1.el9", + "srpm_name": "librepo", + "srpm_nevra": "librepo-0:1.14.5-1.el9.src", + "version": "1.14.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-libs", + "release": "1.el9_2.1", + "srpm_name": "python3.9", + "srpm_nevra": "python3.9-0:3.9.16-1.el9_2.1.src", + "version": "3.9.16", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-pip-wheel", + "release": "6.el9", + "srpm_name": "python-pip", + "srpm_nevra": "python-pip-0:21.2.3-6.el9.src", + "version": "21.2.3", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-pysocks", + "release": "12.el9", + "srpm_name": "python-pysocks", + "srpm_nevra": "python-pysocks-0:1.7.1-12.el9.src", + "version": "1.7.1", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-requests", + "release": "6.el9", + "srpm_name": "python-requests", + "srpm_nevra": "python-requests-0:2.25.1-6.el9.src", + "version": "2.25.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-rpm", + "release": "22.el9", + "srpm_name": "rpm", + "srpm_nevra": "rpm-0:4.16.1.3-22.el9.src", + "version": "4.16.1.3", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-setuptools", + "release": "12.el9", + "srpm_name": "python-setuptools", + "srpm_nevra": "python-setuptools-0:53.0.0-12.el9.src", + "version": "53.0.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-setuptools-wheel", + "release": "12.el9", + "srpm_name": "python-setuptools", + "srpm_nevra": "python-setuptools-0:53.0.0-12.el9.src", + "version": "53.0.0", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-six", + "release": "9.el9", + "srpm_name": "python-six", + "srpm_nevra": "python-six-0:1.15.0-9.el9.src", + "version": "1.15.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-subscription-manager-rhsm", + "release": "1.el9_2", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-0:1.29.33.1-1.el9_2.src", + "version": "1.29.33.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "python3-systemd", + "release": "18.el9", + "srpm_name": "python-systemd", + "srpm_nevra": "python-systemd-234-18.el9.src", + "version": "234", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "python3-urllib3", + "release": "3.el9", + "srpm_name": "python-urllib3", + "srpm_nevra": "python-urllib3-0:1.26.5-3.el9.src", + "version": "1.26.5", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "readline", + "release": "4.el9", + "srpm_name": "readline", + "srpm_nevra": "readline-0:8.1-4.el9.src", + "version": "8.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "redhat-release", + "release": "0.13.el9", + "srpm_name": "redhat-release", + "srpm_nevra": "redhat-release-0:9.2-0.13.el9.src", + "version": "9.2", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "rootfiles", + "release": "31.el9", + "srpm_name": "rootfiles", + "srpm_nevra": "rootfiles-0:8.1-31.el9.src", + "version": "8.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "rpm", + "release": "22.el9", + "srpm_name": "rpm", + "srpm_nevra": "rpm-0:4.16.1.3-22.el9.src", + "version": "4.16.1.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "rpm-build-libs", + "release": "22.el9", + "srpm_name": "rpm", + "srpm_nevra": "rpm-0:4.16.1.3-22.el9.src", + "version": "4.16.1.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "rpm-libs", + "release": "22.el9", + "srpm_name": "rpm", + "srpm_nevra": "rpm-0:4.16.1.3-22.el9.src", + "version": "4.16.1.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "rpm-sign-libs", + "release": "22.el9", + "srpm_name": "rpm", + "srpm_nevra": "rpm-0:4.16.1.3-22.el9.src", + "version": "4.16.1.3", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "rsync", + "release": "19.el9", + "srpm_name": "rsync", + "srpm_nevra": "rsync-0:3.2.3-19.el9.src", + "version": "3.2.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "scl-utils", + "release": "4.el9", + "srpm_name": "scl-utils", + "srpm_nevra": "scl-utils-1:2.0.3-4.el9.src", + "version": "2.0.3", + "_repositoryhint": "repoid=rhel-9-for-x86_64-appstream-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "sed", + "release": "9.el9", + "srpm_name": "sed", + "srpm_nevra": "sed-0:4.8-9.el9.src", + "version": "4.8", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "setup", + "release": "9.el9", + "srpm_name": "setup", + "srpm_nevra": "setup-0:2.13.7-9.el9.src", + "version": "2.13.7", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "shadow-utils", + "release": "6.el9", + "srpm_name": "shadow-utils", + "srpm_nevra": "shadow-utils-2:4.9-6.el9.src", + "version": "4.9", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "sqlite-libs", + "release": "6.el9_1", + "srpm_name": "sqlite", + "srpm_nevra": "sqlite-0:3.34.1-6.el9_1.src", + "version": "3.34.1", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "subscription-manager", + "release": "1.el9_2", + "srpm_name": "subscription-manager", + "srpm_nevra": "subscription-manager-0:1.29.33.1-1.el9_2.src", + "version": "1.29.33.1", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "subscription-manager-rhsm-certificates", + "release": "1.el9", + "srpm_name": "subscription-manager-rhsm-certificates", + "srpm_nevra": "subscription-manager-rhsm-certificates-0:20220623-1.el9.src", + "version": "20220623", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "systemd", + "release": "14.el9_2.1", + "srpm_name": "systemd", + "srpm_nevra": "systemd-0:252-14.el9_2.1.src", + "version": "252", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "systemd-libs", + "release": "14.el9_2.1", + "srpm_name": "systemd", + "srpm_nevra": "systemd-0:252-14.el9_2.1.src", + "version": "252", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "systemd-pam", + "release": "14.el9_2.1", + "srpm_name": "systemd", + "srpm_nevra": "systemd-0:252-14.el9_2.1.src", + "version": "252", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "systemd-rpm-macros", + "release": "14.el9_2.1", + "srpm_name": "systemd", + "srpm_nevra": "systemd-0:252-14.el9_2.1.src", + "version": "252", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "tar", + "release": "6.el9_1", + "srpm_name": "tar", + "srpm_nevra": "tar-2:1.34-6.el9_1.src", + "version": "1.34", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "tcl", + "release": "7.el9", + "srpm_name": "tcl", + "srpm_nevra": "tcl-1:8.6.10-7.el9.src", + "version": "8.6.10", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "tpm2-tss", + "release": "8.el9", + "srpm_name": "tpm2-tss", + "srpm_nevra": "tpm2-tss-0:3.0.3-8.el9.src", + "version": "3.0.3", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "tzdata", + "release": "1.el9", + "srpm_name": "tzdata", + "srpm_nevra": "tzdata-0:2023c-1.el9.src", + "version": "2023c", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "unzip", + "release": "56.el9", + "srpm_name": "unzip", + "srpm_nevra": "unzip-0:6.0-56.el9.src", + "version": "6.0", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "usermode", + "release": "4.el9", + "srpm_name": "usermode", + "srpm_nevra": "usermode-0:1.114-4.el9.src", + "version": "1.114", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "util-linux", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "util-linux-core", + "release": "11.el9_2", + "srpm_name": "util-linux", + "srpm_nevra": "util-linux-0:2.37.4-11.el9_2.src", + "version": "2.37.4", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "vim-filesystem", + "release": "20.el9_1", + "srpm_name": "vim", + "srpm_nevra": "vim-2:8.2.2637-20.el9_1.src", + "version": "8.2.2637", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "vim-minimal", + "release": "20.el9_1", + "srpm_name": "vim", + "srpm_nevra": "vim-2:8.2.2637-20.el9_1.src", + "version": "8.2.2637", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "virt-what", + "release": "3.el9", + "srpm_name": "virt-what", + "srpm_nevra": "virt-what-0:1.25-3.el9.src", + "version": "1.25", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "which", + "release": "28.el9", + "srpm_name": "which", + "srpm_nevra": "which-0:2.21-28.el9.src", + "version": "2.21", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "xz", + "release": "8.el9_0", + "srpm_name": "xz", + "srpm_nevra": "xz-0:5.2.5-8.el9_0.src", + "version": "5.2.5", + "_repositoryhint": "repoid=rhel-9-for-x86_64-baseos-rpms" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "xz-libs", + "release": "8.el9_0", + "srpm_name": "xz", + "srpm_nevra": "xz-0:5.2.5-8.el9_0.src", + "version": "5.2.5", + "_repositoryhint": "" + }, + { + "architecture": "noarch", + "gpg": "199e2f91fd431d51", + "name": "yum", + "release": "5.el9_2", + "srpm_name": "dnf", + "srpm_nevra": "dnf-0:4.14.0-5.el9.src", + "version": "4.14.0", + "_repositoryhint": "" + }, + { + "architecture": "x86_64", + "gpg": "199e2f91fd431d51", + "name": "zlib", + "release": "39.el9", + "srpm_name": "zlib", + "srpm_nevra": "zlib-0:1.2.11-39.el9.src", + "version": "1.2.11", + "_repositoryhint": "" + } + ] +} diff --git a/rhel/testdata/package/ubi8_ubi.txtar b/rhel/testdata/package/ubi8_ubi.txtar new file mode 100644 index 000000000..e1e167adf --- /dev/null +++ b/rhel/testdata/package/ubi8_ubi.txtar @@ -0,0 +1,26 @@ +Generator: fetch-container-rpm-manifest +Version: (devel) +Created: 2025-05-13T15:03:37-05:00 +Search-Term: repository:ubi8/ubi +Url: https://access.redhat.com/hydra/rest/search/kcs?fl=id%2Crepository%2Cregistry%2Cparsed_data_layers&fq=documentKind%3A%22ContainerRepository%22&fq=-eol_date%3A%5B%2A+TO+NOW%5D&fq=repository%3Aubi8%2Fubi&q=%2A&redhat_client=claircore%2Ffetch-container-rpm-manifest&rows=10 +Url: https://catalog.redhat.com/api/containers/v1/repositories/id/5c359854d70cc534b3a3784e +Url: https://catalog.redhat.com/api/containers/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/images?exclude=data.brew%2Cdata.certified%2Cdata.container_grades%2Cdata.content_sets%2Cdata.cpe_ids%2Cdata.docker_image_id%2Cdata.freshness_grades%2Cdata.parsed_data.command%2Cdata.parsed_data.comment%2Cdata.parsed_data.docker_version%2Cdata.parsed_data.env_variables%2Cdata.parsed_data.labels%2Cdata.parsed_data.ports%2Cdata.parsed_data.size%2Cdata.parsed_data.uncompressed_size_bytes%2Cdata.parsed_data.user%2Cdata.raw_config%2Cdata.repositories%2Cdata.sum_layer_size_bytes%2Cdata.top_layer_id%2Cdata.uncompressed_top_layer_id&filter=deleted%21%3Dtrue&page=0&page_size=6&sort_by=creation_date%5Basc%5D +Url: https://catalog.redhat.com/api/containers/v1/images/id/5cc9ca3ddd19c7782937e026/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/5cc9ca3fdd19c7782937e02c/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/5cc9ca42dd19c7782937e032/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/5cc9ca44dd19c7782937e03e/rpm-manifest + +-- access.redhat.com/hydra/rest/search/kcs -- +{"spellcheck":{"collations":[],"suggestions":[]},"response":{"docs":[{"parsed_data_layers":["sha256:58379e595e248ff9da9e51f17234ebae3b1434ca01031ae2d62caa28e714a222"],"registry":"registry.access.redhat.com","id":"5c359854d70cc534b3a3784e","repository":"ubi8/ubi"}],"numFound":1,"start":0,"maxScore":2,"numFoundExact":true},"responseHeader":{"QTime":35,"zkConnected":true,"params":{"ps":"3","bf":"if(exists(pulls_in_last_30_days),sqrt(log(map(pulls_in_last_30_days,0,0,1))),1)","fl":"id,repository,registry,parsed_data_layers","q.op":"AND","fq":["documentKind:\"ContainerRepository\"","-eol_date:[* TO NOW]","repository:ubi8/ubi"," -documentKind:( ApplicationAttribute )","-accessState:(private OR retired) AND -hasPublishedRevision:false","-doNotDisplay:true"],"isAuthenticated":"false","ps2":"3","q.orig":"*","ps3":"3","defType":"edismax","spellcheck.q":"*","trace":["host: restprod04","method: GET","uri: /rs/search","route: portal","collection: access"],"redhat_client":"claircore/fetch-container-rpm-manifest","qf":"psfa^10.0 psfb^5.5 psfc^4.5 psfd^3.5 psfe^4.0 psff^2.5 psfg^2.0","matchtype":"exact","hl.fl":"abstract","wt":"json","mm":"0","start":"0","sort":"score desc,id asc","rows":"10","reqId":"ID-hydra-search-api-prod-57-7tsbg-1747146228218-0-164317","isInternal":"false","q":"*","enableElevation":"true","spellcheck":"true","pf":"psfa^12.0 psfb^5.0 psfc^4.0 psfd^3.5 psfe^4.0 psff^2.5 psfg^2.0","boost":["map(query({!field f='view_uri' v='https://access.redhat.com/downloads/content/package-browser'}), 0, 0, 1, 260.64342)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/8409'}), 0, 0, 1, 124.98317)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/914003'}), 0, 0, 1, 122.75514)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/29036'}), 0, 0, 1, 121.28655)","map(query({!field f='view_uri' v='https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/considerations_in_adopting_rhel_9/'}), 0, 0, 1, 105.7091)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/1378093'}), 0, 0, 1, 82.3566)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/4078831'}), 0, 0, 1, 79.10734)","map(query({!field f='view_uri' v='https://access.redhat.com/discussions/4311201'}), 0, 0, 1, 63.29097)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/simple-content-access'}), 0, 0, 1, 60.65626)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/17215'}), 0, 0, 1, 58.7909)"],"showRetired":"false","pf3":"psfa^7.0 psfb^3.0 psfc^3.5 psfd^2.5 psfe^2.5 psff^1.0 psfg^1.0","pf2":"psfa^2.0 psfb^1.5 psfc^1.0 psfd^1.0 psfe^1.5 psff^1.0 psfg^1.0"},"status":0}} +-- catalog.redhat.com/api/containers/v1/repositories/id/5c359854d70cc534b3a3784e -- +{"_id":"5c359854d70cc534b3a3784e","application_categories":["Operating System"],"architectures":["Base Image"],"auto_rebuild_tags":["latest"],"build_categories":["Scratch image"],"can_auto_release_cve_rebuild":false,"content_stream_grades":[{"grade":"A","image_ids":[{"arch":"s390x","id":"67ff7613cf7feea6ecdd0954"},{"arch":"arm64","id":"67ff761617ac1cd8d6f2722b"},{"arch":"amd64","id":"67ff76174fc3c4d9e9d8c544"},{"arch":"ppc64le","id":"67ff7619fbeb816f6606c09c"}],"tag":"latest"}],"content_stream_tags":["latest"],"creation_date":"2019-01-09T06:44:36.544000+00:00","description":"Provides the latest release of the Red Hat Universal Base Image 8","display_data":{"long_description":"
The Universal Base Image is designed and engineered to be the base layer for all of your containerized applications, middleware and utilities. This base image is freely redistributable, but Red Hat only supports Red Hat technologies through subscriptions for Red Hat products. This image is maintained by Red Hat and updated regularly.
","long_description_markdown":"The Universal Base Image is designed and engineered to be the base layer for all of your containerized applications, middleware and utilities. This base image is freely redistributable, but Red Hat only supports Red Hat technologies through subscriptions for Red Hat products. This image is maintained by Red Hat and updated regularly.","name":"Red Hat Universal Base Image 8","openshift_tags":"base, ubi, ubi8, universal base image","short_description":"Provides the latest release of the Red Hat Universal Base Image 8."},"documentation_links":[{"title":"Understanding the UBI standard images","type":"Documentation","url":"https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html-single/building_running_and_managing_containers/index#con_understanding-the-ubi-standard-images_assembly_types-of-container-images"}],"fbc_opt_in":false,"freshness_grades_unknown_until_date":null,"includes_multiple_content_streams":false,"last_update_date":"2025-05-06T12:38:22.770000+00:00","metadata_source":"quay","namespace":"ubi8","non_production_only":false,"object_type":"containerRepository","privileged_images_allowed":false,"product_listings":["5ec53f50ef29fd35586d9a56"],"protected_for_pull":false,"protected_for_search":false,"published":true,"registry":"registry.access.redhat.com","registry_target":"redhat-prod","release_categories":["Generally Available"],"repository":"ubi8/ubi","requires_terms":false,"source_container_image_enabled":true,"total_size_bytes":29126602125,"total_uncompressed_size_bytes":86228596819,"use_latest":true,"vendor_label":"redhat","_links":{"certification_project":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/projects/certification"},"images":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/images"},"operator_bundles":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/operators/bundles"},"product_listings":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/product-listings"},"vendor":{"href":"/v1/vendors/label/redhat"}}} +-- catalog.redhat.com/api/containers/v1/repositories/registry/registry.access.redhat.com/repository/ubi8/ubi/images -- +{"data":[{"_id":"5cc9ca3ddd19c7782937e026","architecture":"amd64","creation_date":"2019-05-01T16:33:01.431000+00:00","image_id":"sha256:fc84b5febd328eccaa913807716887b3eb5ed08bc22cc6933a9ebf82766725e3","last_update_date":"2024-09-06T10:09:55.434000+00:00","object_type":"containerImage","parsed_data":{"architecture":"amd64","created":"2019-04-25T16:26:28.425556Z","layers":["sha256:6a5240d60dc4e1ade0d103badb2a897e8103ebf0ebe08350cd582bbc9671cc7a","sha256:787f47dbeaac926cc8c927a48e8a84fc97e05fbd1c08a4c9c4ddcaddfd87e2f7"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:c613b100be1645941fded703dd6037e5aba7c9388fd1fcb37c2f9f73bc438126","size_bytes":3514},{"layer_id":"sha256:24d85c895b6b870f6b84327a5e31aa567a5d30588de0a0bdd9a669ec5012339c","size_bytes":207551435}]},"_links":{"artifacts":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026/artifacts"},"requests":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026/requests"},"rpm_manifest":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026/rpm-manifest"},"test_results":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026/test-results"},"vulnerabilities":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026/vulnerabilities"}}},{"_id":"5cc9ca3fdd19c7782937e02c","architecture":"arm64","creation_date":"2019-05-01T16:33:03.924000+00:00","image_id":"sha256:7c9bc776305d1c1936e64e8654368b0823007d1a26feae7d42d2d61b409441e8","last_update_date":"2024-09-06T10:10:01.043000+00:00","object_type":"containerImage","parsed_data":{"architecture":"arm64","created":"2019-04-25T16:26:55.276398Z","layers":["sha256:5c81e99f07ac7e7097717a822ba3e0391688cfb60e88448c47dc8831a6bbd45f","sha256:c8eae873ab5f8062f94c6044f709b82048cc855535677aab3461835d6e05e959"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:411c5f46d8008dd59111739feb651bbd05b74c3fde71a30efe963eb37fea065f","size_bytes":3513},{"layer_id":"sha256:c49242bcb4bae74c60af8c927e78f5141a813c75d8f766ecd564364ce92ba791","size_bytes":238488177}]},"_links":{"artifacts":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c/artifacts"},"requests":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c/requests"},"rpm_manifest":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c/rpm-manifest"},"test_results":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c/test-results"},"vulnerabilities":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c/vulnerabilities"}}},{"_id":"5cc9ca42dd19c7782937e032","architecture":"ppc64le","creation_date":"2019-05-01T16:33:06.150000+00:00","image_id":"sha256:560636f0e8ad995cc284c8ef63be38730db36f26f744af31b210cc68d48c8d7e","last_update_date":"2024-09-06T10:10:03.457000+00:00","object_type":"containerImage","parsed_data":{"architecture":"ppc64le","created":"2019-04-25T16:23:38.052788Z","layers":["sha256:e7548d1dc2dd34d444691eb2d667876ae24c4f4f83a86dbd9e05fca34f9db05b","sha256:3df8f8b02970dc739003bbac3f7c9c2cc514eb6bc6a2af28e6f8b23a487fbfd6"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:5b396ed7b96ed87e2aa919a5ab622810e0d2c171a85c607d2e4a18a2323b5d2e","size_bytes":3519},{"layer_id":"sha256:4f4d77ef659ad7e98164b181cb858f98673f3346dd2eebc2eb784416563c50a4","size_bytes":268395724}]},"_links":{"artifacts":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032/artifacts"},"requests":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032/requests"},"rpm_manifest":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032/rpm-manifest"},"test_results":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032/test-results"},"vulnerabilities":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032/vulnerabilities"}}},{"_id":"5cc9ca44dd19c7782937e03e","architecture":"s390x","creation_date":"2019-05-01T16:33:08.330000+00:00","image_id":"sha256:3f0f9d8b4c133eee9495211bb0ca431a14cdb32ee9ec1c3cba5ff02562960281","last_update_date":"2024-09-06T10:10:05.724000+00:00","object_type":"containerImage","parsed_data":{"architecture":"s390x","created":"2019-04-25T16:26:43.019235Z","layers":["sha256:45299504ade1327fddcbe5e18bd22d915409c22f2b1e4960aec2713dc378b2da","sha256:396ddd18963a1c43260127403ba8e9e20e03b37adb69627f541df3b607e658f6"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:531155794457a67ef0aad9842794f333a195087479c81c518da15209f71e3e10","size_bytes":3512},{"layer_id":"sha256:a2bc6bab696889ea2e45ea04e7ac710dee8b6b37d3a480fe6e91fc878320bcb6","size_bytes":202500358}]},"_links":{"artifacts":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e/artifacts"},"requests":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e/requests"},"rpm_manifest":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e/rpm-manifest"},"test_results":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e/test-results"},"vulnerabilities":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e/vulnerabilities"}}},{"_id":"5d099880d70cc57c44bef91f","architecture":"amd64","creation_date":"2019-06-19T02:05:52.216000+00:00","image_id":"sha256:284eedc1810e91ec2778d5baa848939b8fcaa3414ddb9c09def6b413561602b2","last_update_date":"2024-09-06T10:10:07.778000+00:00","object_type":"containerImage","parsed_data":{"architecture":"amd64","created":"2019-06-11T09:38:21.230674Z","layers":["sha256:7e0f5f7bc63fab93173f321e9ab56ffb184a36b2793f82aa9bca46a145bf9a95","sha256:89f1c7157a2d8d40f6bf7346d0db6d49dda64fd84a549895b307ae0ed72936a9"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:77ba31c86fd4def6e9925f74c62ce954d6fca2164bc00ff3619c2e5d276eb3bb","size_bytes":3548},{"layer_id":"sha256:4144b1ae544bd17e45e4980a9e00c13eee6e9792e43ee9896035993b9b2f28d5","size_bytes":207554295}]},"_links":{"artifacts":{"href":"/v1/images/id/5d099880d70cc57c44bef91f/artifacts"},"requests":{"href":"/v1/images/id/5d099880d70cc57c44bef91f/requests"},"rpm_manifest":{"href":"/v1/images/id/5d099880d70cc57c44bef91f/rpm-manifest"},"test_results":{"href":"/v1/images/id/5d099880d70cc57c44bef91f/test-results"},"vulnerabilities":{"href":"/v1/images/id/5d099880d70cc57c44bef91f/vulnerabilities"}}},{"_id":"5d099881d70cc57c44bef925","architecture":"arm64","creation_date":"2019-06-19T02:05:53.999000+00:00","image_id":"sha256:5f4c2d256ebf1f650481c7b5e2c9de0a619ddae1a6bda40519f77cc0bc5ca52c","last_update_date":"2024-09-06T10:10:19.353000+00:00","object_type":"containerImage","parsed_data":{"architecture":"arm64","created":"2019-06-11T09:38:56.943958Z","layers":["sha256:100a628bc0f6218e09156e27f602534d3f9dd852fa38861c098d3f9ab7fcf1af","sha256:7074ebd1d24a01f9985a982a0d383ceb2ce1d5eee19976d9b6aa93e2387c84c9"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:9a9cf5226a6ea9a61763bae92f6e92953ca92f61012e1e9618624207614e0306","size_bytes":3547},{"layer_id":"sha256:bd232ebc8cc7a3a7fe2f750dd14f8f05ab06e140091d4a88184f422005022c73","size_bytes":238483337}]},"_links":{"artifacts":{"href":"/v1/images/id/5d099881d70cc57c44bef925/artifacts"},"requests":{"href":"/v1/images/id/5d099881d70cc57c44bef925/requests"},"rpm_manifest":{"href":"/v1/images/id/5d099881d70cc57c44bef925/rpm-manifest"},"test_results":{"href":"/v1/images/id/5d099881d70cc57c44bef925/test-results"},"vulnerabilities":{"href":"/v1/images/id/5d099881d70cc57c44bef925/vulnerabilities"}}}],"page":0,"page_size":6,"total":368} +-- catalog.redhat.com/api/containers/v1/images/id/5cc9ca3ddd19c7782937e026/rpm-manifest -- +{"_id":"5cc9ca3edd19c7782937e02a","creation_date":"2019-05-01T16:33:02.778000+00:00","image_id":"5cc9ca3ddd19c7782937e026","last_update_date":"2024-09-06T10:09:56.886000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.1.1-4.el8.x86_64","release":"4.el8","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.1.1-4.el8.src","summary":"Extended crypt library for DES, MD5, Blowfish and others","version":"4.1.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.1-6.el8.x86_64","release":"6.el8","srpm_name":"grep","srpm_nevra":"grep-0:3.1-6.el8.src","summary":"Pattern matching utilities","version":"3.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.3.4-10.el8.x86_64","release":"10.el8","srpm_name":"lua","srpm_nevra":"lua-0:5.3.4-10.el8.src","summary":"Libraries for lua","version":"5.3.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-10.el8.x86_64","release":"10.el8","srpm_name":"which","srpm_nevra":"which-0:2.21-10.el8.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.9-4.el8.x86_64","release":"4.el8","srpm_name":"gzip","srpm_nevra":"gzip-0:1.9-4.el8.src","summary":"The GNU data compression program","version":"1.9"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.6-26.el8.x86_64","release":"26.el8","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.6-26.el8.src","summary":"Libraries for applications using bzip2","version":"1.0.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.5-1.el8.x86_64","release":"1.el8","srpm_name":"sed","srpm_nevra":"sed-0:4.5-1.el8.src","summary":"A GNU stream text editor","version":"4.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.30-4.el8.x86_64","release":"4.el8","srpm_name":"tar","srpm_nevra":"tar-2:1.30-4.el8.src","summary":"A GNU file archiving program","version":"1.30"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-4.2.1-1.el8.x86_64","release":"1.el8","srpm_name":"gawk","srpm_nevra":"gawk-0:4.2.1-1.el8.src","summary":"The GNU version of the AWK text processing utility","version":"4.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-5.el8.noarch","release":"5.el8","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-5.el8.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.2.53-1.el8.x86_64","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Dynamic library for access control list support","version":"2.2.53"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.2.53-1.el8.x86_64","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Access control list utilities","version":"2.2.53"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.4.48-3.el8.x86_64","release":"3.el8","srpm_name":"attr","srpm_nevra":"attr-0:2.4.48-3.el8.src","summary":"Dynamic library for extended attribute support","version":"2.4.48"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-0.3rc7.el8.x86_64","release":"0.3rc7.el8","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-0.3rc7.el8.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-glib","nvra":"dbus-glib-0.110-2.el8.x86_64","release":"2.el8","srpm_name":"dbus-glib","srpm_nevra":"dbus-glib-0:0.110-2.el8.src","summary":"GLib bindings for D-Bus","version":"0.110"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.4-14.el8.x86_64","release":"14.el8","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.4-14.el8.src","summary":"D-Bus bindings for python3","version":"1.2.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.8-2.el8.x86_64","release":"2.el8","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.8-2.el8.src","summary":"The basic directory layout for a Linux system","version":"3.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.5-3.el8.x86_64","release":"3.el8","srpm_name":"expat","srpm_nevra":"expat-0:2.2.5-3.el8.src","summary":"An XML parser library","version":"2.2.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.7-5.el8.x86_64","release":"5.el8","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.7-5.el8.src","summary":"Library providing XML and HTML support","version":"2.9.7"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libxml2","nvra":"python3-libxml2-2.9.7-5.el8.x86_64","release":"5.el8","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.7-5.el8.src","summary":"Python 3 bindings for the libxml2 library","version":"2.9.7"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.1.2-8.el8.x86_64","release":"8.el8","srpm_name":"gmp","srpm_nevra":"gmp-1:6.1.2-8.el8.src","summary":"A GNU arbitrary precision library","version":"6.1.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.2.1-2.el8.noarch","release":"2.el8","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.2.1-2.el8.src","summary":"Module to simplify usage of decorators in python3","version":"4.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.56.1-1.el8.x86_64","release":"1.el8","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.56.1-1.el8.src","summary":"Introspection system for GObject-based libraries","version":"1.56.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-1.0-12.el8.noarch","release":"12.el8","srpm_name":"langpacks","srpm_nevra":"langpacks-0:1.0-12.el8.src","summary":"English langpacks meta-package","version":"1.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.6.1-6.el8.noarch","release":"6.el8","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.6.1-6.el8.src","summary":"Powerful extensions to the standard datetime module","version":"2.6.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.2.9-1.el8.x86_64","release":"1.el8","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.2.9-1.el8.src","summary":"Utility for secure communication and data storage","version":"2.2.9"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-31.el8.noarch","release":"31.el8","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-31.el8.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.13.1-0.2.el8.x86_64","release":"0.2.el8","srpm_name":"json-c","srpm_nevra":"json-c-0:0.13.1-0.2.el8.src","summary":"JSON implementation in C","version":"0.13.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.5.10-6.el8.x86_64","release":"6.el8","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.5.10-6.el8.src","summary":"Key utilities library","version":"1.5.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.1-3.el8.x86_64","release":"3.el8","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.1-3.el8.src","summary":"GnuPG IPC library","version":"2.5.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.25-9.el8.x86_64","release":"9.el8","srpm_name":"libcap","srpm_nevra":"libcap-0:2.25-9.el8.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.25"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.31-1.el8.x86_64","release":"1.el8","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.31-1.el8.src","summary":"Library for error values used by GnuPG components","version":"1.31"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.8.3-2.el8.x86_64","release":"2.el8","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.8.3-2.el8.src","summary":"A general-purpose cryptography library","version":"1.8.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.0.5-1.el8.x86_64","release":"1.el8","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.0.5-1.el8.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.0.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libmetalink","nvra":"libmetalink-0.1.3-7.el8.x86_64","release":"7.el8","srpm_name":"libmetalink","srpm_nevra":"libmetalink-0:0.1.3-7.el8.src","summary":"Metalink library written in C","version":"0.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.3.5-7.el8.x86_64","release":"7.el8","srpm_name":"libksba","srpm_nevra":"libksba-0:1.3.5-7.el8.src","summary":"CMS and X.509 library","version":"1.3.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.3.2-3.el8.x86_64","release":"3.el8","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.3.2-3.el8.src","summary":"A library for handling streaming archive formats","version":"3.3.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libnsl2","nvra":"libnsl2-1.2.0-2.20180605git4a062cf.el8.x86_64","release":"2.20180605git4a062cf.el8","srpm_name":"libnsl2","srpm_nevra":"libnsl2-0:1.2.0-2.20180605git4a062cf.el8.src","summary":"Public client interface library for NIS(YP) and NIS+","version":"1.2.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.4.0-4.el8.x86_64","release":"4.el8","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.4.0-4.el8.src","summary":"Convenience library for kernel netlink sockets","version":"3.4.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libpsl","nvra":"libpsl-0.20.2-5.el8.x86_64","release":"5.el8","srpm_name":"libpsl","srpm_nevra":"libpsl-0:0.20.2-5.el8.src","summary":"C library for the Publix Suffix List","version":"0.20.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libpcap","nvra":"libpcap-1.9.0-1.el8.x86_64","release":"1.el8","srpm_name":"libpcap","srpm_nevra":"libpcap-14:1.9.0-1.el8.src","summary":"A system-independent interface for user-level packet capture","version":"1.9.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.11-5.el8.x86_64","release":"5.el8","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.11-5.el8.src","summary":"Library for handling page faults in user mode","version":"2.11"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.3.3-3.el8.x86_64","release":"3.el8","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.3.3-3.el8.src","summary":"Enhanced seccomp library","version":"2.3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.13-3.el8.x86_64","release":"3.el8","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.13-3.el8.src","summary":"The ASN.1 library used in GNUTLS","version":"4.13"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.1.6-14.el8.x86_64","release":"14.el8","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.1.6-14.el8.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.1.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.0-5.el8.x86_64","release":"5.el8","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.0-5.el8.src","summary":"Main loop abstraction library","version":"0.3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.11.0-8.el8.noarch","release":"8.el8","srpm_name":"python-six","srpm_nevra":"python-six-0:1.11.0-8.el8.src","summary":"Python 2 and 3 compatibility utilities","version":"1.11.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.1.7-5.el8.x86_64","release":"5.el8","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.1.7-5.el8.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.1.7"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.8.1.2-4.el8.x86_64","release":"4.el8","srpm_name":"lz4","srpm_nevra":"lz4-0:1.8.1.2-4.el8.src","summary":"Libaries for lz4","version":"1.8.1.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-3.1.6-1.el8.x86_64","release":"1.el8","srpm_name":"mpfr","srpm_nevra":"mpfr-0:3.1.6-1.el8.src","summary":"A C library for multiple-precision floating-point computations","version":"3.1.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.5-4.el8.x86_64","release":"4.el8","srpm_name":"npth","srpm_nevra":"npth-0:1.5-4.el8.src","summary":"The New GNU Portable Threads library","version":"1.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"publicsuffix-list-dafsa","nvra":"publicsuffix-list-dafsa-20180723-1.el8.noarch","release":"1.el8","srpm_name":"publicsuffix-list","srpm_nevra":"publicsuffix-list-0:20180723-1.el8.src","summary":"Cross-vendor public domain suffix database in DAFSA form","version":"20180723"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-2.el8.x86_64","release":"2.el8","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-2.el8.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-10.el8.x86_64","release":"10.el8","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-10.el8.src","summary":"The compression and decompression library","version":"1.2.11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pkgconf-m4","nvra":"pkgconf-m4-1.4.2-1.el8.noarch","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"m4 macros for pkgconf","version":"1.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pkgconf-pkg-config","nvra":"pkgconf-pkg-config-1.4.2-1.el8.x86_64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"pkgconf shim to provide /usr/bin/pkg-config","version":"1.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pkgconf","nvra":"pkgconf-1.4.2-1.el8.x86_64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Package compiler and linker metadata toolkit","version":"1.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libpkgconf","nvra":"libpkgconf-1.4.2-1.el8.x86_64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Backend library for pkgconf","version":"1.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.16-14.el8.x86_64","release":"14.el8","srpm_name":"popt","srpm_nevra":"popt-0:1.16-14.el8.src","summary":"C library for parsing command line parameters","version":"1.16"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.28.3-1.el8.x86_64","release":"1.el8","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.28.3-1.el8.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.28.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-7.0-10.el8.x86_64","release":"10.el8","srpm_name":"readline","srpm_nevra":"readline-0:7.0-10.el8.src","summary":"A library for editing typed command lines","version":"7.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2018.2.24-6.el8.noarch","release":"6.el8","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2018.2.24-6.el8.src","summary":"The Mozilla CA root certificate bundle","version":"2018.2.24"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.9-3.el8.x86_64","release":"3.el8","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.9-3.el8.src","summary":"GNU Unicode string library","version":"0.9.9"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libusbx","nvra":"libusbx-1.0.22-1.el8.x86_64","release":"1.el8","srpm_name":"libusbx","srpm_nevra":"libusbx-0:1.0.22-1.el8.src","summary":"Library for accessing USB devices","version":"1.0.22"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.9.5-6.el8.x86_64","release":"6.el8","srpm_name":"libreport","srpm_nevra":"libreport-0:2.9.5-6.el8.src","summary":"Filesystem layout for libreport","version":"2.9.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.42-4.el8.x86_64","release":"4.el8","srpm_name":"pcre","srpm_nevra":"pcre-0:8.42-4.el8.src","summary":"Perl-compatible regular expression library","version":"8.42"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.12.2-1.el8.noarch","release":"1.el8","srpm_name":"setup","srpm_nevra":"setup-0:2.12.2-1.el8.src","summary":"A set of system configuration and setup files","version":"2.12.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"chkconfig","nvra":"chkconfig-1.11-1.el8.x86_64","release":"1.el8","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.11-1.el8.src","summary":"A system tool for maintaining the /etc/rc*.d hierarchy","version":"1.11"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-dmidecode","nvra":"python3-dmidecode-3.12.2-13.el8.x86_64","release":"13.el8","srpm_name":"python-dmidecode","srpm_nevra":"python-dmidecode-0:3.12.2-13.el8.src","summary":"Python 3 module to access DMI data","version":"3.12.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dmidecode","nvra":"dmidecode-3.2-1.el8.x86_64","release":"1.el8","srpm_name":"dmidecode","srpm_nevra":"dmidecode-1:3.2-1.el8.src","summary":"Tool to analyse BIOS DMI data","version":"3.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.9.2-1.el8.x86_64","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Python 3 bindings for the librepo library","version":"1.9.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.9.2-1.el8.x86_64","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Repodata downloading library","version":"1.9.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.18-1.el8.x86_64","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"Libraries files for gdbm","version":"1.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gdbm","nvra":"gdbm-1.18-1.el8.x86_64","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"A GNU set of database routines which use extensible hashing","version":"1.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libtirpc","nvra":"libtirpc-1.1.4-3.el8.x86_64","release":"3.el8","srpm_name":"libtirpc","srpm_nevra":"libtirpc-0:1.1.4-3.el8.src","summary":"Transport Independent RPC Library","version":"1.1.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"info","nvra":"info-6.5-4.el8.x86_64","release":"4.el8","srpm_name":"texinfo","srpm_nevra":"texinfo-0:6.5-4.el8.src","summary":"A stand-alone TTY-based reader for GNU texinfo documentation","version":"6.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.33.0-1.el8.x86_64","release":"1.el8","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.33.0-1.el8.src","summary":"A library implementing the HTTP/2 protocol","version":"1.33.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"brotli","nvra":"brotli-1.0.6-1.el8.x86_64","release":"1.el8","srpm_name":"brotli","srpm_nevra":"brotli-0:1.0.6-1.el8.src","summary":"Lossless compression algorithm","version":"1.0.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.4.4-1.el8.x86_64","release":"1.el8","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.4.4-1.el8.src","summary":"Library for JavaScript Object Notation format","version":"1.4.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.0-9.el8.x86_64","release":"9.el8","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.0-9.el8.src","summary":"A library for password generation and password quality checking","version":"1.4.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.8-7.el8.noarch","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus configuration","version":"1.12.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-daemon","nvra":"dbus-daemon-1.12.8-7.el8.x86_64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.8-7.el8.x86_64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"Libraries for accessing D-BUS","version":"1.12.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-tools","nvra":"dbus-tools-1.12.8-7.el8.x86_64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS Tools and Utilities","version":"1.12.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.8-7.el8.x86_64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-setuptools","nvra":"platform-python-setuptools-39.2.0-4.el8.noarch","release":"4.el8","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:39.2.0-4.el8.src","summary":"Easily build and distribute Python 3 packages","version":"39.2.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.1-4.el8.x86_64","release":"4.el8","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.1-4.el8.src","summary":"IMA/EVM support utilities","version":"1.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.18-6.el8.x86_64","release":"6.el8","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.18-6.el8.src","summary":"Detect if we are running in a virtual machine","version":"1.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.6.0-20.el8.x86_64","release":"20.el8","srpm_name":"findutils","srpm_nevra":"findutils-1:4.6.0-20.el8.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.6.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.33-8.el8.x86_64","release":"8.el8","srpm_name":"file","srpm_nevra":"file-0:5.33-8.el8.src","summary":"Libraries for applications using libmagic","version":"5.33"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-2.8-2.el8.x86_64","release":"2.el8","srpm_name":"libsepol","srpm_nevra":"libsepol-0:2.8-2.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-2.8-6.el8.x86_64","release":"6.el8","srpm_name":"libselinux","srpm_nevra":"libselinux-0:2.8-6.el8.src","summary":"SELinux library and simple utilities","version":"2.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-2.el8.x86_64","release":"2.el8","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-2.el8.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-13.el8.noarch","release":"13.el8","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-13.el8.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.113-1.el8.x86_64","release":"1.el8","srpm_name":"usermode","srpm_nevra":"usermode-0:1.113-1.el8.src","summary":"Tools for certain user account management tasks","version":"1.113"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.10.0-6.el8.x86_64","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"gpgme bindings for Python 3","version":"1.10.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.10.0-6.el8.x86_64","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.10.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.4-3.el8.x86_64","release":"3.el8","srpm_name":"xz","srpm_nevra":"xz-0:5.2.4-3.el8.src","summary":"Libraries for decoding LZMA compression","version":"5.2.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-15.el8.x86_64","release":"15.el8","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-15.el8.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.1-18.el8.x86_64","release":"18.el8","srpm_name":"libffi","srpm_nevra":"libffi-0:3.1-18.el8.src","summary":"A portable foreign function interface library","version":"3.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.62-21.el8.x86_64","release":"21.el8","srpm_name":"libuser","srpm_nevra":"libuser-0:0.62-21.el8.src","summary":"A user and group account administration library","version":"0.62"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.0.6-1.el8.x86_64","release":"1.el8","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.0.6-1.el8.src","summary":"Cryptsetup shared library","version":"2.0.6"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.174-6.el8.noarch","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Default yama attach scope sysctl setting","version":"0.174"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.174-6.el8.x86_64","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Library to read and write ELF files","version":"0.174"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.174-6.el8.x86_64","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Libraries to handle compiled objects","version":"0.174"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.0.1763-10.el8.x86_64","release":"10.el8","srpm_name":"vim","srpm_nevra":"vim-2:8.0.1763-10.el8.src","summary":"A minimal version of the VIM editor","version":"8.0.1763"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-2.8-5.el8.x86_64","release":"5.el8","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:2.8-5.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.3.1-4.el8.x86_64","release":"4.el8","srpm_name":"pam","srpm_nevra":"pam-0:1.3.1-4.el8.src","summary":"An extensible library which provides authentication for applications","version":"1.3.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.14-3.el8.x86_64","release":"3.el8","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.14-3.el8.src","summary":"Python module to interface with ethtool","version":"0.14"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-8.2.1-3.5.el8.x86_64","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GNU Standard C++ Library","version":"8.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-8.2.1-3.5.el8.x86_64","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GCC version 8 shared support library","version":"8.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Partitioning library for fdisk-like programs.","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"A collection of basic system utilities","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Universally unique ID library","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Device mounting library","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Block device ID library","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.32.1-8.el8.x86_64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Formatting library for ls-like programs.","version":"2.32.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.4.1-1.el8.x86_64","release":"1.el8","srpm_name":"nettle","srpm_nevra":"nettle-0:3.4.1-1.el8.src","summary":"A low-level cryptographic library","version":"3.4.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.8-13.el8.x86_64","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Comps XML file manipulation library","version":"0.1.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.8-13.el8.x86_64","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Python 3 bindings for libcomps library","version":"0.1.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-1.1.1-8.el8.x86_64","release":"8.el8","srpm_name":"openssl","srpm_nevra":"openssl-1:1.1.1-8.el8.src","summary":"A general purpose cryptography library with TLS implementation","version":"1.1.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.32-1.el8.x86_64","release":"1.el8","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.32-1.el8.src","summary":"Perl-compatible regular expression library","version":"10.32"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libssh","nvra":"libssh-0.8.5-2.el8.x86_64","release":"2.el8","srpm_name":"libssh","srpm_nevra":"libssh-0:0.8.5-2.el8.src","summary":"A library implementing the SSH protocol","version":"0.8.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-pip","nvra":"platform-python-pip-9.0.3-13.el8.noarch","release":"13.el8","srpm_name":"python-pip","srpm_nevra":"python-pip-0:9.0.3-13.el8.src","summary":"A tool for installing and managing Python3 packages","version":"9.0.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.44.3-2.el8.x86_64","release":"2.el8","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.44.3-2.el8.src","summary":"Common error description library","version":"1.44.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.46-9.el8.x86_64","release":"9.el8","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.46-9.el8.src","summary":"LDAP support libraries","version":"2.4.46"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.6-7.el8.x86_64","release":"7.el8","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.6-7.el8.src","summary":"Utilities for managing accounts and shadow password files","version":"4.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.14.2-9.el8.x86_64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for building and signing RPM packages","version":"4.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.14.2-9.el8.x86_64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.14.2-9.el8.x86_64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"The RPM package management system","version":"4.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.14.2-9.el8.x86_64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for manipulating RPM packages","version":"4.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.26.0-3.el8.x86_64","release":"3.el8","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.26.0-3.el8.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.26.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.2.2-3.el8.noarch","release":"3.el8","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.2.2-3.el8.src","summary":"Core Plugins for DNF","version":"4.0.2.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.7.9-4.el8.x86_64","release":"4.el8","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.7.9-4.el8.src","summary":"An alternate posix capabilities library","version":"0.7.9"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0-0.10.20180831git0047a6c.el8.x86_64","release":"0.10.20180831git0047a6c.el8","srpm_name":"audit","srpm_nevra":"audit-0:3.0-0.10.20180831git0047a6c.el8.src","summary":"Dynamic library for libaudit","version":"3.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcurl","nvra":"libcurl-7.61.1-8.el8.x86_64","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A library for getting files from web servers","version":"7.61.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"curl","nvra":"curl-7.61.1-8.el8.x86_64","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A utility for getting files from remote servers (FTP, HTTP, and others)","version":"7.61.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.6.5-2.el8.x86_64","release":"2.el8","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.6.5-2.el8.src","summary":"A TLS protocol implementation","version":"3.6.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.30-6.el8.x86_64","release":"6.el8","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.30-6.el8.src","summary":"coreutils multicall binary","version":"8.30"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-8.2-5.el8.x86_64","release":"5.el8","srpm_name":"gdb","srpm_nevra":"gdb-0:8.2-5.el8.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"8.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-4.4.19-7.el8.x86_64","release":"7.el8","srpm_name":"bash","srpm_nevra":"bash-0:4.4.19-7.el8.src","summary":"The GNU Bourne Again shell","version":"4.4.19"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.56.4-1.el8.x86_64","release":"1.el8","srpm_name":"glib2","srpm_nevra":"glib2-0:2.56.4-1.el8.src","summary":"A library of handy utility functions","version":"2.56.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.1-7.20180224.el8.noarch","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Descriptions of common terminals","version":"6.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.1-7.20180224.el8.x86_64","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Ncurses libraries","version":"6.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libmodulemd1","nvra":"libmodulemd1-1.8.0-5.el8.x86_64","release":"5.el8","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.0.0-5.el8.src","summary":"Compatibility package for libmodulemd 1.x","version":"1.8.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-36.el8.x86_64","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdb-utils","nvra":"libdb-utils-5.3.28-36.el8.x86_64","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"Command line tools for managing Berkeley DB databases","version":"5.3.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.16.1-22.el8.x86_64","release":"22.el8","srpm_name":"krb5","srpm_nevra":"krb5-0:1.16.1-22.el8.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.16.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.6.35-6.el8.x86_64","release":"6.el8","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.6.35-6.el8.src","summary":"Package dependency solver","version":"0.6.35"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"iptables-libs","nvra":"iptables-libs-1.8.2-9.el8.x86_64","release":"9.el8","srpm_name":"iptables","srpm_nevra":"iptables-0:1.8.2-9.el8.src","summary":"iptables libraries","version":"1.8.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Common data and configuration files for DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Python 3 interface to DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20181217-6.git9a35207.el8.noarch","release":"6.git9a35207.el8","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20181217-6.git9a35207.el8.src","summary":"Systemwide crypto policies","version":"20181217"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.155-6.el8.x86_64","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device-mapper shared library","version":"1.02.155"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.155-6.el8.x86_64","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device mapper utility","version":"1.02.155"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-8.0-0.44.el8.x86_64","release":"0.44.el8","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:8.0-0.44.el8.src","summary":"Red Hat Enterprise Linux release file","version":"8.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.23.8-35.el8.x86_64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-syspurpose","nvra":"python3-syspurpose-1.23.8-35.el8.x86_64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A commandline utility for declaring system syspurpose","version":"1.23.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.23.8-35.el8.x86_64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Tools and libraries for subscription and repository management","version":"1.23.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dnf-plugin-subscription-manager","nvra":"dnf-plugin-subscription-manager-1.23.8-35.el8.x86_64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Subscription Manager plugins for DNF","version":"1.23.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.23.8-35.el8.x86_64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2019a-1.el8.noarch","release":"1.el8","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2019a-1.el8.src","summary":"Timezone data","version":"2019a"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.23.14-5.el8_0.x86_64","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"System trust module from p11-kit","version":"0.23.14"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.23.14-5.el8_0.x86_64","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.23.14"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.28-42.el8_0.1.x86_64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Minimal language packs for glibc.","version":"2.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.28-42.el8_0.1.x86_64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Common binaries and locale data for glibc","version":"2.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.28-42.el8_0.1.x86_64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"The GNU libc libraries","version":"2.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.22.5-5.el8_0.x86_64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.22.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.22.5-5.el8_0.x86_64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.22.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.22.5-5.el8_0.x86_64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.22.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-25-11.el8_0.2.x86_64","release":"11.el8_0.2","srpm_name":"kmod","srpm_nevra":"kmod-0:25-11.el8_0.2.src","summary":"Libraries to handle kernel module loading and unloading","version":"25"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"platform-python","nvra":"platform-python-3.6.8-2.el8_0.x86_64","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Internal interpreter of the Python programming language","version":"3.6.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.6.8-2.el8_0.x86_64","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Python runtime libraries","version":"3.6.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-239-13.el8_0.3.x86_64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"System and Service Manager","version":"239"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-239-13.el8_0.3.x86_64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd PAM module","version":"239"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-239-13.el8_0.3.x86_64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd libraries","version":"239"}],"_links":{"image":{"href":"/v1/images/id/5cc9ca3ddd19c7782937e026"}}} +-- catalog.redhat.com/api/containers/v1/images/id/5cc9ca3fdd19c7782937e02c/rpm-manifest -- +{"_id":"5cc9ca41dd19c7782937e030","creation_date":"2019-05-01T16:33:05.234000+00:00","image_id":"5cc9ca3fdd19c7782937e02c","last_update_date":"2024-09-06T10:10:02.345000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.1.1-4.el8.aarch64","release":"4.el8","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.1.1-4.el8.src","summary":"Extended crypt library for DES, MD5, Blowfish and others","version":"4.1.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.1-6.el8.aarch64","release":"6.el8","srpm_name":"grep","srpm_nevra":"grep-0:3.1-6.el8.src","summary":"Pattern matching utilities","version":"3.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.3.4-10.el8.aarch64","release":"10.el8","srpm_name":"lua","srpm_nevra":"lua-0:5.3.4-10.el8.src","summary":"Libraries for lua","version":"5.3.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-10.el8.aarch64","release":"10.el8","srpm_name":"which","srpm_nevra":"which-0:2.21-10.el8.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.9-4.el8.aarch64","release":"4.el8","srpm_name":"gzip","srpm_nevra":"gzip-0:1.9-4.el8.src","summary":"The GNU data compression program","version":"1.9"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.6-26.el8.aarch64","release":"26.el8","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.6-26.el8.src","summary":"Libraries for applications using bzip2","version":"1.0.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.5-1.el8.aarch64","release":"1.el8","srpm_name":"sed","srpm_nevra":"sed-0:4.5-1.el8.src","summary":"A GNU stream text editor","version":"4.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.30-4.el8.aarch64","release":"4.el8","srpm_name":"tar","srpm_nevra":"tar-2:1.30-4.el8.src","summary":"A GNU file archiving program","version":"1.30"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-4.2.1-1.el8.aarch64","release":"1.el8","srpm_name":"gawk","srpm_nevra":"gawk-0:4.2.1-1.el8.src","summary":"The GNU version of the AWK text processing utility","version":"4.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-5.el8.noarch","release":"5.el8","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-5.el8.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.2.53-1.el8.aarch64","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Access control list utilities","version":"2.2.53"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.2.53-1.el8.aarch64","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Dynamic library for access control list support","version":"2.2.53"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.4.48-3.el8.aarch64","release":"3.el8","srpm_name":"attr","srpm_nevra":"attr-0:2.4.48-3.el8.src","summary":"Dynamic library for extended attribute support","version":"2.4.48"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-0.3rc7.el8.aarch64","release":"0.3rc7.el8","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-0.3rc7.el8.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-glib","nvra":"dbus-glib-0.110-2.el8.aarch64","release":"2.el8","srpm_name":"dbus-glib","srpm_nevra":"dbus-glib-0:0.110-2.el8.src","summary":"GLib bindings for D-Bus","version":"0.110"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.4-14.el8.aarch64","release":"14.el8","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.4-14.el8.src","summary":"D-Bus bindings for python3","version":"1.2.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.8-2.el8.aarch64","release":"2.el8","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.8-2.el8.src","summary":"The basic directory layout for a Linux system","version":"3.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.5-3.el8.aarch64","release":"3.el8","srpm_name":"expat","srpm_nevra":"expat-0:2.2.5-3.el8.src","summary":"An XML parser library","version":"2.2.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.7-5.el8.aarch64","release":"5.el8","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.7-5.el8.src","summary":"Library providing XML and HTML support","version":"2.9.7"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.1.2-8.el8.aarch64","release":"8.el8","srpm_name":"gmp","srpm_nevra":"gmp-1:6.1.2-8.el8.src","summary":"A GNU arbitrary precision library","version":"6.1.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.2.1-2.el8.noarch","release":"2.el8","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.2.1-2.el8.src","summary":"Module to simplify usage of decorators in python3","version":"4.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.56.1-1.el8.aarch64","release":"1.el8","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.56.1-1.el8.src","summary":"Introspection system for GObject-based libraries","version":"1.56.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-1.0-12.el8.noarch","release":"12.el8","srpm_name":"langpacks","srpm_nevra":"langpacks-0:1.0-12.el8.src","summary":"English langpacks meta-package","version":"1.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.6.1-6.el8.noarch","release":"6.el8","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.6.1-6.el8.src","summary":"Powerful extensions to the standard datetime module","version":"2.6.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.2.9-1.el8.aarch64","release":"1.el8","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.2.9-1.el8.src","summary":"Utility for secure communication and data storage","version":"2.2.9"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-31.el8.noarch","release":"31.el8","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-31.el8.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.13.1-0.2.el8.aarch64","release":"0.2.el8","srpm_name":"json-c","srpm_nevra":"json-c-0:0.13.1-0.2.el8.src","summary":"JSON implementation in C","version":"0.13.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.5.10-6.el8.aarch64","release":"6.el8","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.5.10-6.el8.src","summary":"Key utilities library","version":"1.5.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.1-3.el8.aarch64","release":"3.el8","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.1-3.el8.src","summary":"GnuPG IPC library","version":"2.5.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.25-9.el8.aarch64","release":"9.el8","srpm_name":"libcap","srpm_nevra":"libcap-0:2.25-9.el8.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.25"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.31-1.el8.aarch64","release":"1.el8","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.31-1.el8.src","summary":"Library for error values used by GnuPG components","version":"1.31"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.8.3-2.el8.aarch64","release":"2.el8","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.8.3-2.el8.src","summary":"A general-purpose cryptography library","version":"1.8.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.0.5-1.el8.aarch64","release":"1.el8","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.0.5-1.el8.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.0.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libmetalink","nvra":"libmetalink-0.1.3-7.el8.aarch64","release":"7.el8","srpm_name":"libmetalink","srpm_nevra":"libmetalink-0:0.1.3-7.el8.src","summary":"Metalink library written in C","version":"0.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.3.5-7.el8.aarch64","release":"7.el8","srpm_name":"libksba","srpm_nevra":"libksba-0:1.3.5-7.el8.src","summary":"CMS and X.509 library","version":"1.3.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.3.2-3.el8.aarch64","release":"3.el8","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.3.2-3.el8.src","summary":"A library for handling streaming archive formats","version":"3.3.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libnsl2","nvra":"libnsl2-1.2.0-2.20180605git4a062cf.el8.aarch64","release":"2.20180605git4a062cf.el8","srpm_name":"libnsl2","srpm_nevra":"libnsl2-0:1.2.0-2.20180605git4a062cf.el8.src","summary":"Public client interface library for NIS(YP) and NIS+","version":"1.2.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.4.0-4.el8.aarch64","release":"4.el8","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.4.0-4.el8.src","summary":"Convenience library for kernel netlink sockets","version":"3.4.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libpsl","nvra":"libpsl-0.20.2-5.el8.aarch64","release":"5.el8","srpm_name":"libpsl","srpm_nevra":"libpsl-0:0.20.2-5.el8.src","summary":"C library for the Publix Suffix List","version":"0.20.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libpcap","nvra":"libpcap-1.9.0-1.el8.aarch64","release":"1.el8","srpm_name":"libpcap","srpm_nevra":"libpcap-14:1.9.0-1.el8.src","summary":"A system-independent interface for user-level packet capture","version":"1.9.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.11-5.el8.aarch64","release":"5.el8","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.11-5.el8.src","summary":"Library for handling page faults in user mode","version":"2.11"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.3.3-3.el8.aarch64","release":"3.el8","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.3.3-3.el8.src","summary":"Enhanced seccomp library","version":"2.3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.13-3.el8.aarch64","release":"3.el8","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.13-3.el8.src","summary":"The ASN.1 library used in GNUTLS","version":"4.13"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.1.6-14.el8.aarch64","release":"14.el8","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.1.6-14.el8.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.1.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.0-5.el8.aarch64","release":"5.el8","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.0-5.el8.src","summary":"Main loop abstraction library","version":"0.3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.11.0-8.el8.noarch","release":"8.el8","srpm_name":"python-six","srpm_nevra":"python-six-0:1.11.0-8.el8.src","summary":"Python 2 and 3 compatibility utilities","version":"1.11.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.1.7-5.el8.aarch64","release":"5.el8","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.1.7-5.el8.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.1.7"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.8.1.2-4.el8.aarch64","release":"4.el8","srpm_name":"lz4","srpm_nevra":"lz4-0:1.8.1.2-4.el8.src","summary":"Libaries for lz4","version":"1.8.1.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-3.1.6-1.el8.aarch64","release":"1.el8","srpm_name":"mpfr","srpm_nevra":"mpfr-0:3.1.6-1.el8.src","summary":"A C library for multiple-precision floating-point computations","version":"3.1.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.5-4.el8.aarch64","release":"4.el8","srpm_name":"npth","srpm_nevra":"npth-0:1.5-4.el8.src","summary":"The New GNU Portable Threads library","version":"1.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"publicsuffix-list-dafsa","nvra":"publicsuffix-list-dafsa-20180723-1.el8.noarch","release":"1.el8","srpm_name":"publicsuffix-list","srpm_nevra":"publicsuffix-list-0:20180723-1.el8.src","summary":"Cross-vendor public domain suffix database in DAFSA form","version":"20180723"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-2.el8.aarch64","release":"2.el8","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-2.el8.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-10.el8.aarch64","release":"10.el8","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-10.el8.src","summary":"The compression and decompression library","version":"1.2.11"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pkgconf","nvra":"pkgconf-1.4.2-1.el8.aarch64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Package compiler and linker metadata toolkit","version":"1.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pkgconf-pkg-config","nvra":"pkgconf-pkg-config-1.4.2-1.el8.aarch64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"pkgconf shim to provide /usr/bin/pkg-config","version":"1.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libpkgconf","nvra":"libpkgconf-1.4.2-1.el8.aarch64","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Backend library for pkgconf","version":"1.4.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pkgconf-m4","nvra":"pkgconf-m4-1.4.2-1.el8.noarch","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"m4 macros for pkgconf","version":"1.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.16-14.el8.aarch64","release":"14.el8","srpm_name":"popt","srpm_nevra":"popt-0:1.16-14.el8.src","summary":"C library for parsing command line parameters","version":"1.16"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.28.3-1.el8.aarch64","release":"1.el8","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.28.3-1.el8.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.28.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-7.0-10.el8.aarch64","release":"10.el8","srpm_name":"readline","srpm_nevra":"readline-0:7.0-10.el8.src","summary":"A library for editing typed command lines","version":"7.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2018.2.24-6.el8.noarch","release":"6.el8","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2018.2.24-6.el8.src","summary":"The Mozilla CA root certificate bundle","version":"2018.2.24"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.9-3.el8.aarch64","release":"3.el8","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.9-3.el8.src","summary":"GNU Unicode string library","version":"0.9.9"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libusbx","nvra":"libusbx-1.0.22-1.el8.aarch64","release":"1.el8","srpm_name":"libusbx","srpm_nevra":"libusbx-0:1.0.22-1.el8.src","summary":"Library for accessing USB devices","version":"1.0.22"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.9.5-6.el8.aarch64","release":"6.el8","srpm_name":"libreport","srpm_nevra":"libreport-0:2.9.5-6.el8.src","summary":"Filesystem layout for libreport","version":"2.9.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.42-4.el8.aarch64","release":"4.el8","srpm_name":"pcre","srpm_nevra":"pcre-0:8.42-4.el8.src","summary":"Perl-compatible regular expression library","version":"8.42"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.12.2-1.el8.noarch","release":"1.el8","srpm_name":"setup","srpm_nevra":"setup-0:2.12.2-1.el8.src","summary":"A set of system configuration and setup files","version":"2.12.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"chkconfig","nvra":"chkconfig-1.11-1.el8.aarch64","release":"1.el8","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.11-1.el8.src","summary":"A system tool for maintaining the /etc/rc*.d hierarchy","version":"1.11"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dmidecode","nvra":"dmidecode-3.2-1.el8.aarch64","release":"1.el8","srpm_name":"dmidecode","srpm_nevra":"dmidecode-1:3.2-1.el8.src","summary":"Tool to analyse BIOS DMI data","version":"3.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.9.2-1.el8.aarch64","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Repodata downloading library","version":"1.9.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.9.2-1.el8.aarch64","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Python 3 bindings for the librepo library","version":"1.9.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.18-1.el8.aarch64","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"Libraries files for gdbm","version":"1.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gdbm","nvra":"gdbm-1.18-1.el8.aarch64","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"A GNU set of database routines which use extensible hashing","version":"1.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libtirpc","nvra":"libtirpc-1.1.4-3.el8.aarch64","release":"3.el8","srpm_name":"libtirpc","srpm_nevra":"libtirpc-0:1.1.4-3.el8.src","summary":"Transport Independent RPC Library","version":"1.1.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"info","nvra":"info-6.5-4.el8.aarch64","release":"4.el8","srpm_name":"texinfo","srpm_nevra":"texinfo-0:6.5-4.el8.src","summary":"A stand-alone TTY-based reader for GNU texinfo documentation","version":"6.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.33.0-1.el8.aarch64","release":"1.el8","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.33.0-1.el8.src","summary":"A library implementing the HTTP/2 protocol","version":"1.33.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"brotli","nvra":"brotli-1.0.6-1.el8.aarch64","release":"1.el8","srpm_name":"brotli","srpm_nevra":"brotli-0:1.0.6-1.el8.src","summary":"Lossless compression algorithm","version":"1.0.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.4.4-1.el8.aarch64","release":"1.el8","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.4.4-1.el8.src","summary":"Library for JavaScript Object Notation format","version":"1.4.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.0-9.el8.aarch64","release":"9.el8","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.0-9.el8.src","summary":"A library for password generation and password quality checking","version":"1.4.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.8-7.el8.aarch64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-daemon","nvra":"dbus-daemon-1.12.8-7.el8.aarch64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-tools","nvra":"dbus-tools-1.12.8-7.el8.aarch64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS Tools and Utilities","version":"1.12.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.8-7.el8.noarch","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus configuration","version":"1.12.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.8-7.el8.aarch64","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"Libraries for accessing D-BUS","version":"1.12.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-setuptools","nvra":"platform-python-setuptools-39.2.0-4.el8.noarch","release":"4.el8","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:39.2.0-4.el8.src","summary":"Easily build and distribute Python 3 packages","version":"39.2.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.1-4.el8.aarch64","release":"4.el8","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.1-4.el8.src","summary":"IMA/EVM support utilities","version":"1.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.18-6.el8.aarch64","release":"6.el8","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.18-6.el8.src","summary":"Detect if we are running in a virtual machine","version":"1.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.6.0-20.el8.aarch64","release":"20.el8","srpm_name":"findutils","srpm_nevra":"findutils-1:4.6.0-20.el8.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.6.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.33-8.el8.aarch64","release":"8.el8","srpm_name":"file","srpm_nevra":"file-0:5.33-8.el8.src","summary":"Libraries for applications using libmagic","version":"5.33"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-2.8-2.el8.aarch64","release":"2.el8","srpm_name":"libsepol","srpm_nevra":"libsepol-0:2.8-2.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-2.8-6.el8.aarch64","release":"6.el8","srpm_name":"libselinux","srpm_nevra":"libselinux-0:2.8-6.el8.src","summary":"SELinux library and simple utilities","version":"2.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-2.el8.aarch64","release":"2.el8","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-2.el8.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-13.el8.noarch","release":"13.el8","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-13.el8.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.113-1.el8.aarch64","release":"1.el8","srpm_name":"usermode","srpm_nevra":"usermode-0:1.113-1.el8.src","summary":"Tools for certain user account management tasks","version":"1.113"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.10.0-6.el8.aarch64","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.10.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.10.0-6.el8.aarch64","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"gpgme bindings for Python 3","version":"1.10.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.4-3.el8.aarch64","release":"3.el8","srpm_name":"xz","srpm_nevra":"xz-0:5.2.4-3.el8.src","summary":"Libraries for decoding LZMA compression","version":"5.2.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-15.el8.aarch64","release":"15.el8","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-15.el8.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.1-18.el8.aarch64","release":"18.el8","srpm_name":"libffi","srpm_nevra":"libffi-0:3.1-18.el8.src","summary":"A portable foreign function interface library","version":"3.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.62-21.el8.aarch64","release":"21.el8","srpm_name":"libuser","srpm_nevra":"libuser-0:0.62-21.el8.src","summary":"A user and group account administration library","version":"0.62"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.0.6-1.el8.aarch64","release":"1.el8","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.0.6-1.el8.src","summary":"Cryptsetup shared library","version":"2.0.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.174-6.el8.aarch64","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Libraries to handle compiled objects","version":"0.174"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.174-6.el8.noarch","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Default yama attach scope sysctl setting","version":"0.174"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.174-6.el8.aarch64","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Library to read and write ELF files","version":"0.174"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.0.1763-10.el8.aarch64","release":"10.el8","srpm_name":"vim","srpm_nevra":"vim-2:8.0.1763-10.el8.src","summary":"A minimal version of the VIM editor","version":"8.0.1763"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-2.8-5.el8.aarch64","release":"5.el8","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:2.8-5.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.3.1-4.el8.aarch64","release":"4.el8","srpm_name":"pam","srpm_nevra":"pam-0:1.3.1-4.el8.src","summary":"An extensible library which provides authentication for applications","version":"1.3.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.14-3.el8.aarch64","release":"3.el8","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.14-3.el8.src","summary":"Python module to interface with ethtool","version":"0.14"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-8.2.1-3.5.el8.aarch64","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GNU Standard C++ Library","version":"8.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-8.2.1-3.5.el8.aarch64","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GCC version 8 shared support library","version":"8.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Partitioning library for fdisk-like programs.","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Device mounting library","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Formatting library for ls-like programs.","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"A collection of basic system utilities","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Block device ID library","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.32.1-8.el8.aarch64","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Universally unique ID library","version":"2.32.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.4.1-1.el8.aarch64","release":"1.el8","srpm_name":"nettle","srpm_nevra":"nettle-0:3.4.1-1.el8.src","summary":"A low-level cryptographic library","version":"3.4.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.8-13.el8.aarch64","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Python 3 bindings for libcomps library","version":"0.1.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.8-13.el8.aarch64","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Comps XML file manipulation library","version":"0.1.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-1.1.1-8.el8.aarch64","release":"8.el8","srpm_name":"openssl","srpm_nevra":"openssl-1:1.1.1-8.el8.src","summary":"A general purpose cryptography library with TLS implementation","version":"1.1.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.32-1.el8.aarch64","release":"1.el8","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.32-1.el8.src","summary":"Perl-compatible regular expression library","version":"10.32"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libssh","nvra":"libssh-0.8.5-2.el8.aarch64","release":"2.el8","srpm_name":"libssh","srpm_nevra":"libssh-0:0.8.5-2.el8.src","summary":"A library implementing the SSH protocol","version":"0.8.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-pip","nvra":"platform-python-pip-9.0.3-13.el8.noarch","release":"13.el8","srpm_name":"python-pip","srpm_nevra":"python-pip-0:9.0.3-13.el8.src","summary":"A tool for installing and managing Python3 packages","version":"9.0.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.44.3-2.el8.aarch64","release":"2.el8","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.44.3-2.el8.src","summary":"Common error description library","version":"1.44.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.46-9.el8.aarch64","release":"9.el8","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.46-9.el8.src","summary":"LDAP support libraries","version":"2.4.46"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.6-7.el8.aarch64","release":"7.el8","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.6-7.el8.src","summary":"Utilities for managing accounts and shadow password files","version":"4.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.14.2-9.el8.aarch64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for building and signing RPM packages","version":"4.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.14.2-9.el8.aarch64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"The RPM package management system","version":"4.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.14.2-9.el8.aarch64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.14.2-9.el8.aarch64","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for manipulating RPM packages","version":"4.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.26.0-3.el8.aarch64","release":"3.el8","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.26.0-3.el8.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.26.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.2.2-3.el8.noarch","release":"3.el8","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.2.2-3.el8.src","summary":"Core Plugins for DNF","version":"4.0.2.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.7.9-4.el8.aarch64","release":"4.el8","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.7.9-4.el8.src","summary":"An alternate posix capabilities library","version":"0.7.9"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0-0.10.20180831git0047a6c.el8.aarch64","release":"0.10.20180831git0047a6c.el8","srpm_name":"audit","srpm_nevra":"audit-0:3.0-0.10.20180831git0047a6c.el8.src","summary":"Dynamic library for libaudit","version":"3.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"curl","nvra":"curl-7.61.1-8.el8.aarch64","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A utility for getting files from remote servers (FTP, HTTP, and others)","version":"7.61.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcurl","nvra":"libcurl-7.61.1-8.el8.aarch64","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A library for getting files from web servers","version":"7.61.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.6.5-2.el8.aarch64","release":"2.el8","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.6.5-2.el8.src","summary":"A TLS protocol implementation","version":"3.6.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.30-6.el8.aarch64","release":"6.el8","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.30-6.el8.src","summary":"coreutils multicall binary","version":"8.30"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-8.2-5.el8.aarch64","release":"5.el8","srpm_name":"gdb","srpm_nevra":"gdb-0:8.2-5.el8.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"8.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-4.4.19-7.el8.aarch64","release":"7.el8","srpm_name":"bash","srpm_nevra":"bash-0:4.4.19-7.el8.src","summary":"The GNU Bourne Again shell","version":"4.4.19"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.56.4-1.el8.aarch64","release":"1.el8","srpm_name":"glib2","srpm_nevra":"glib2-0:2.56.4-1.el8.src","summary":"A library of handy utility functions","version":"2.56.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.1-7.20180224.el8.aarch64","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Ncurses libraries","version":"6.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.1-7.20180224.el8.noarch","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Descriptions of common terminals","version":"6.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libmodulemd1","nvra":"libmodulemd1-1.8.0-5.el8.aarch64","release":"5.el8","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.0.0-5.el8.src","summary":"Compatibility package for libmodulemd 1.x","version":"1.8.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-36.el8.aarch64","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdb-utils","nvra":"libdb-utils-5.3.28-36.el8.aarch64","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"Command line tools for managing Berkeley DB databases","version":"5.3.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.16.1-22.el8.aarch64","release":"22.el8","srpm_name":"krb5","srpm_nevra":"krb5-0:1.16.1-22.el8.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.16.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.6.35-6.el8.aarch64","release":"6.el8","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.6.35-6.el8.src","summary":"Package dependency solver","version":"0.6.35"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"iptables-libs","nvra":"iptables-libs-1.8.2-9.el8.aarch64","release":"9.el8","srpm_name":"iptables","srpm_nevra":"iptables-0:1.8.2-9.el8.src","summary":"iptables libraries","version":"1.8.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Common data and configuration files for DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Python 3 interface to DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20181217-6.git9a35207.el8.noarch","release":"6.git9a35207.el8","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20181217-6.git9a35207.el8.src","summary":"Systemwide crypto policies","version":"20181217"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.155-6.el8.aarch64","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device mapper utility","version":"1.02.155"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.155-6.el8.aarch64","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device-mapper shared library","version":"1.02.155"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-8.0-0.44.el8.aarch64","release":"0.44.el8","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:8.0-0.44.el8.src","summary":"Red Hat Enterprise Linux release file","version":"8.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.23.8-35.el8.aarch64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.23.8-35.el8.aarch64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.23.8-35.el8.aarch64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Tools and libraries for subscription and repository management","version":"1.23.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dnf-plugin-subscription-manager","nvra":"dnf-plugin-subscription-manager-1.23.8-35.el8.aarch64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Subscription Manager plugins for DNF","version":"1.23.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-syspurpose","nvra":"python3-syspurpose-1.23.8-35.el8.aarch64","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A commandline utility for declaring system syspurpose","version":"1.23.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2019a-1.el8.noarch","release":"1.el8","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2019a-1.el8.src","summary":"Timezone data","version":"2019a"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.23.14-5.el8_0.aarch64","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.23.14"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.23.14-5.el8_0.aarch64","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"System trust module from p11-kit","version":"0.23.14"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.28-42.el8_0.1.aarch64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Common binaries and locale data for glibc","version":"2.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.28-42.el8_0.1.aarch64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"The GNU libc libraries","version":"2.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.28-42.el8_0.1.aarch64","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Minimal language packs for glibc.","version":"2.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.22.5-5.el8_0.aarch64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.22.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.22.5-5.el8_0.aarch64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.22.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.22.5-5.el8_0.aarch64","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.22.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-25-11.el8_0.2.aarch64","release":"11.el8_0.2","srpm_name":"kmod","srpm_nevra":"kmod-0:25-11.el8_0.2.src","summary":"Libraries to handle kernel module loading and unloading","version":"25"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.6.8-2.el8_0.aarch64","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Python runtime libraries","version":"3.6.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"platform-python","nvra":"platform-python-3.6.8-2.el8_0.aarch64","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Internal interpreter of the Python programming language","version":"3.6.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-239-13.el8_0.3.aarch64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd PAM module","version":"239"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-239-13.el8_0.3.aarch64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd libraries","version":"239"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-239-13.el8_0.3.aarch64","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"System and Service Manager","version":"239"}],"_links":{"image":{"href":"/v1/images/id/5cc9ca3fdd19c7782937e02c"}}} +-- catalog.redhat.com/api/containers/v1/images/id/5cc9ca42dd19c7782937e032/rpm-manifest -- +{"_id":"5cc9ca43dd19c7782937e03a","creation_date":"2019-05-01T16:33:07.428000+00:00","image_id":"5cc9ca42dd19c7782937e032","last_update_date":"2024-09-06T10:10:04.018000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.1.1-4.el8.ppc64le","release":"4.el8","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.1.1-4.el8.src","summary":"Extended crypt library for DES, MD5, Blowfish and others","version":"4.1.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.1-6.el8.ppc64le","release":"6.el8","srpm_name":"grep","srpm_nevra":"grep-0:3.1-6.el8.src","summary":"Pattern matching utilities","version":"3.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.3.4-10.el8.ppc64le","release":"10.el8","srpm_name":"lua","srpm_nevra":"lua-0:5.3.4-10.el8.src","summary":"Libraries for lua","version":"5.3.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-10.el8.ppc64le","release":"10.el8","srpm_name":"which","srpm_nevra":"which-0:2.21-10.el8.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.9-4.el8.ppc64le","release":"4.el8","srpm_name":"gzip","srpm_nevra":"gzip-0:1.9-4.el8.src","summary":"The GNU data compression program","version":"1.9"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.6-26.el8.ppc64le","release":"26.el8","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.6-26.el8.src","summary":"Libraries for applications using bzip2","version":"1.0.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.5-1.el8.ppc64le","release":"1.el8","srpm_name":"sed","srpm_nevra":"sed-0:4.5-1.el8.src","summary":"A GNU stream text editor","version":"4.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.30-4.el8.ppc64le","release":"4.el8","srpm_name":"tar","srpm_nevra":"tar-2:1.30-4.el8.src","summary":"A GNU file archiving program","version":"1.30"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-4.2.1-1.el8.ppc64le","release":"1.el8","srpm_name":"gawk","srpm_nevra":"gawk-0:4.2.1-1.el8.src","summary":"The GNU version of the AWK text processing utility","version":"4.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-5.el8.noarch","release":"5.el8","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-5.el8.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.2.53-1.el8.ppc64le","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Dynamic library for access control list support","version":"2.2.53"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.2.53-1.el8.ppc64le","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Access control list utilities","version":"2.2.53"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.4.48-3.el8.ppc64le","release":"3.el8","srpm_name":"attr","srpm_nevra":"attr-0:2.4.48-3.el8.src","summary":"Dynamic library for extended attribute support","version":"2.4.48"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-0.3rc7.el8.ppc64le","release":"0.3rc7.el8","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-0.3rc7.el8.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-glib","nvra":"dbus-glib-0.110-2.el8.ppc64le","release":"2.el8","srpm_name":"dbus-glib","srpm_nevra":"dbus-glib-0:0.110-2.el8.src","summary":"GLib bindings for D-Bus","version":"0.110"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.4-14.el8.ppc64le","release":"14.el8","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.4-14.el8.src","summary":"D-Bus bindings for python3","version":"1.2.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.8-2.el8.ppc64le","release":"2.el8","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.8-2.el8.src","summary":"The basic directory layout for a Linux system","version":"3.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.5-3.el8.ppc64le","release":"3.el8","srpm_name":"expat","srpm_nevra":"expat-0:2.2.5-3.el8.src","summary":"An XML parser library","version":"2.2.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.7-5.el8.ppc64le","release":"5.el8","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.7-5.el8.src","summary":"Library providing XML and HTML support","version":"2.9.7"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.1.2-8.el8.ppc64le","release":"8.el8","srpm_name":"gmp","srpm_nevra":"gmp-1:6.1.2-8.el8.src","summary":"A GNU arbitrary precision library","version":"6.1.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.2.1-2.el8.noarch","release":"2.el8","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.2.1-2.el8.src","summary":"Module to simplify usage of decorators in python3","version":"4.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.56.1-1.el8.ppc64le","release":"1.el8","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.56.1-1.el8.src","summary":"Introspection system for GObject-based libraries","version":"1.56.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-1.0-12.el8.noarch","release":"12.el8","srpm_name":"langpacks","srpm_nevra":"langpacks-0:1.0-12.el8.src","summary":"English langpacks meta-package","version":"1.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.6.1-6.el8.noarch","release":"6.el8","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.6.1-6.el8.src","summary":"Powerful extensions to the standard datetime module","version":"2.6.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.2.9-1.el8.ppc64le","release":"1.el8","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.2.9-1.el8.src","summary":"Utility for secure communication and data storage","version":"2.2.9"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-31.el8.noarch","release":"31.el8","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-31.el8.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.13.1-0.2.el8.ppc64le","release":"0.2.el8","srpm_name":"json-c","srpm_nevra":"json-c-0:0.13.1-0.2.el8.src","summary":"JSON implementation in C","version":"0.13.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.5.10-6.el8.ppc64le","release":"6.el8","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.5.10-6.el8.src","summary":"Key utilities library","version":"1.5.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.1-3.el8.ppc64le","release":"3.el8","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.1-3.el8.src","summary":"GnuPG IPC library","version":"2.5.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.25-9.el8.ppc64le","release":"9.el8","srpm_name":"libcap","srpm_nevra":"libcap-0:2.25-9.el8.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.25"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.31-1.el8.ppc64le","release":"1.el8","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.31-1.el8.src","summary":"Library for error values used by GnuPG components","version":"1.31"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.8.3-2.el8.ppc64le","release":"2.el8","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.8.3-2.el8.src","summary":"A general-purpose cryptography library","version":"1.8.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.0.5-1.el8.ppc64le","release":"1.el8","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.0.5-1.el8.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.0.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libmetalink","nvra":"libmetalink-0.1.3-7.el8.ppc64le","release":"7.el8","srpm_name":"libmetalink","srpm_nevra":"libmetalink-0:0.1.3-7.el8.src","summary":"Metalink library written in C","version":"0.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.3.5-7.el8.ppc64le","release":"7.el8","srpm_name":"libksba","srpm_nevra":"libksba-0:1.3.5-7.el8.src","summary":"CMS and X.509 library","version":"1.3.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.3.2-3.el8.ppc64le","release":"3.el8","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.3.2-3.el8.src","summary":"A library for handling streaming archive formats","version":"3.3.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libnsl2","nvra":"libnsl2-1.2.0-2.20180605git4a062cf.el8.ppc64le","release":"2.20180605git4a062cf.el8","srpm_name":"libnsl2","srpm_nevra":"libnsl2-0:1.2.0-2.20180605git4a062cf.el8.src","summary":"Public client interface library for NIS(YP) and NIS+","version":"1.2.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.4.0-4.el8.ppc64le","release":"4.el8","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.4.0-4.el8.src","summary":"Convenience library for kernel netlink sockets","version":"3.4.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libpsl","nvra":"libpsl-0.20.2-5.el8.ppc64le","release":"5.el8","srpm_name":"libpsl","srpm_nevra":"libpsl-0:0.20.2-5.el8.src","summary":"C library for the Publix Suffix List","version":"0.20.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libpcap","nvra":"libpcap-1.9.0-1.el8.ppc64le","release":"1.el8","srpm_name":"libpcap","srpm_nevra":"libpcap-14:1.9.0-1.el8.src","summary":"A system-independent interface for user-level packet capture","version":"1.9.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.11-5.el8.ppc64le","release":"5.el8","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.11-5.el8.src","summary":"Library for handling page faults in user mode","version":"2.11"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.3.3-3.el8.ppc64le","release":"3.el8","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.3.3-3.el8.src","summary":"Enhanced seccomp library","version":"2.3.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.13-3.el8.ppc64le","release":"3.el8","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.13-3.el8.src","summary":"The ASN.1 library used in GNUTLS","version":"4.13"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.1.6-14.el8.ppc64le","release":"14.el8","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.1.6-14.el8.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.1.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.0-5.el8.ppc64le","release":"5.el8","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.0-5.el8.src","summary":"Main loop abstraction library","version":"0.3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.11.0-8.el8.noarch","release":"8.el8","srpm_name":"python-six","srpm_nevra":"python-six-0:1.11.0-8.el8.src","summary":"Python 2 and 3 compatibility utilities","version":"1.11.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.1.7-5.el8.ppc64le","release":"5.el8","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.1.7-5.el8.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.1.7"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.8.1.2-4.el8.ppc64le","release":"4.el8","srpm_name":"lz4","srpm_nevra":"lz4-0:1.8.1.2-4.el8.src","summary":"Libaries for lz4","version":"1.8.1.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-3.1.6-1.el8.ppc64le","release":"1.el8","srpm_name":"mpfr","srpm_nevra":"mpfr-0:3.1.6-1.el8.src","summary":"A C library for multiple-precision floating-point computations","version":"3.1.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.5-4.el8.ppc64le","release":"4.el8","srpm_name":"npth","srpm_nevra":"npth-0:1.5-4.el8.src","summary":"The New GNU Portable Threads library","version":"1.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"publicsuffix-list-dafsa","nvra":"publicsuffix-list-dafsa-20180723-1.el8.noarch","release":"1.el8","srpm_name":"publicsuffix-list","srpm_nevra":"publicsuffix-list-0:20180723-1.el8.src","summary":"Cross-vendor public domain suffix database in DAFSA form","version":"20180723"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-2.el8.ppc64le","release":"2.el8","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-2.el8.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-10.el8.ppc64le","release":"10.el8","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-10.el8.src","summary":"The compression and decompression library","version":"1.2.11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pkgconf-m4","nvra":"pkgconf-m4-1.4.2-1.el8.noarch","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"m4 macros for pkgconf","version":"1.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pkgconf","nvra":"pkgconf-1.4.2-1.el8.ppc64le","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Package compiler and linker metadata toolkit","version":"1.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pkgconf-pkg-config","nvra":"pkgconf-pkg-config-1.4.2-1.el8.ppc64le","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"pkgconf shim to provide /usr/bin/pkg-config","version":"1.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libpkgconf","nvra":"libpkgconf-1.4.2-1.el8.ppc64le","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Backend library for pkgconf","version":"1.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.16-14.el8.ppc64le","release":"14.el8","srpm_name":"popt","srpm_nevra":"popt-0:1.16-14.el8.src","summary":"C library for parsing command line parameters","version":"1.16"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.28.3-1.el8.ppc64le","release":"1.el8","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.28.3-1.el8.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.28.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-7.0-10.el8.ppc64le","release":"10.el8","srpm_name":"readline","srpm_nevra":"readline-0:7.0-10.el8.src","summary":"A library for editing typed command lines","version":"7.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2018.2.24-6.el8.noarch","release":"6.el8","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2018.2.24-6.el8.src","summary":"The Mozilla CA root certificate bundle","version":"2018.2.24"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.9-3.el8.ppc64le","release":"3.el8","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.9-3.el8.src","summary":"GNU Unicode string library","version":"0.9.9"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libusbx","nvra":"libusbx-1.0.22-1.el8.ppc64le","release":"1.el8","srpm_name":"libusbx","srpm_nevra":"libusbx-0:1.0.22-1.el8.src","summary":"Library for accessing USB devices","version":"1.0.22"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.9.5-6.el8.ppc64le","release":"6.el8","srpm_name":"libreport","srpm_nevra":"libreport-0:2.9.5-6.el8.src","summary":"Filesystem layout for libreport","version":"2.9.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.42-4.el8.ppc64le","release":"4.el8","srpm_name":"pcre","srpm_nevra":"pcre-0:8.42-4.el8.src","summary":"Perl-compatible regular expression library","version":"8.42"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.12.2-1.el8.noarch","release":"1.el8","srpm_name":"setup","srpm_nevra":"setup-0:2.12.2-1.el8.src","summary":"A set of system configuration and setup files","version":"2.12.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"chkconfig","nvra":"chkconfig-1.11-1.el8.ppc64le","release":"1.el8","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.11-1.el8.src","summary":"A system tool for maintaining the /etc/rc*.d hierarchy","version":"1.11"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.9.2-1.el8.ppc64le","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Python 3 bindings for the librepo library","version":"1.9.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.9.2-1.el8.ppc64le","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Repodata downloading library","version":"1.9.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gdbm","nvra":"gdbm-1.18-1.el8.ppc64le","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"A GNU set of database routines which use extensible hashing","version":"1.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.18-1.el8.ppc64le","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"Libraries files for gdbm","version":"1.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libtirpc","nvra":"libtirpc-1.1.4-3.el8.ppc64le","release":"3.el8","srpm_name":"libtirpc","srpm_nevra":"libtirpc-0:1.1.4-3.el8.src","summary":"Transport Independent RPC Library","version":"1.1.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"info","nvra":"info-6.5-4.el8.ppc64le","release":"4.el8","srpm_name":"texinfo","srpm_nevra":"texinfo-0:6.5-4.el8.src","summary":"A stand-alone TTY-based reader for GNU texinfo documentation","version":"6.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.33.0-1.el8.ppc64le","release":"1.el8","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.33.0-1.el8.src","summary":"A library implementing the HTTP/2 protocol","version":"1.33.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"brotli","nvra":"brotli-1.0.6-1.el8.ppc64le","release":"1.el8","srpm_name":"brotli","srpm_nevra":"brotli-0:1.0.6-1.el8.src","summary":"Lossless compression algorithm","version":"1.0.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.4.4-1.el8.ppc64le","release":"1.el8","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.4.4-1.el8.src","summary":"Library for JavaScript Object Notation format","version":"1.4.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.0-9.el8.ppc64le","release":"9.el8","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.0-9.el8.src","summary":"A library for password generation and password quality checking","version":"1.4.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.8-7.el8.noarch","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus configuration","version":"1.12.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.8-7.el8.ppc64le","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"Libraries for accessing D-BUS","version":"1.12.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.8-7.el8.ppc64le","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-daemon","nvra":"dbus-daemon-1.12.8-7.el8.ppc64le","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-tools","nvra":"dbus-tools-1.12.8-7.el8.ppc64le","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS Tools and Utilities","version":"1.12.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-setuptools","nvra":"platform-python-setuptools-39.2.0-4.el8.noarch","release":"4.el8","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:39.2.0-4.el8.src","summary":"Easily build and distribute Python 3 packages","version":"39.2.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.1-4.el8.ppc64le","release":"4.el8","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.1-4.el8.src","summary":"IMA/EVM support utilities","version":"1.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.18-6.el8.ppc64le","release":"6.el8","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.18-6.el8.src","summary":"Detect if we are running in a virtual machine","version":"1.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.6.0-20.el8.ppc64le","release":"20.el8","srpm_name":"findutils","srpm_nevra":"findutils-1:4.6.0-20.el8.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.6.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.33-8.el8.ppc64le","release":"8.el8","srpm_name":"file","srpm_nevra":"file-0:5.33-8.el8.src","summary":"Libraries for applications using libmagic","version":"5.33"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-2.8-2.el8.ppc64le","release":"2.el8","srpm_name":"libsepol","srpm_nevra":"libsepol-0:2.8-2.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-2.8-6.el8.ppc64le","release":"6.el8","srpm_name":"libselinux","srpm_nevra":"libselinux-0:2.8-6.el8.src","summary":"SELinux library and simple utilities","version":"2.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-2.el8.ppc64le","release":"2.el8","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-2.el8.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-13.el8.noarch","release":"13.el8","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-13.el8.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.113-1.el8.ppc64le","release":"1.el8","srpm_name":"usermode","srpm_nevra":"usermode-0:1.113-1.el8.src","summary":"Tools for certain user account management tasks","version":"1.113"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.10.0-6.el8.ppc64le","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.10.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.10.0-6.el8.ppc64le","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"gpgme bindings for Python 3","version":"1.10.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.4-3.el8.ppc64le","release":"3.el8","srpm_name":"xz","srpm_nevra":"xz-0:5.2.4-3.el8.src","summary":"Libraries for decoding LZMA compression","version":"5.2.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-15.el8.ppc64le","release":"15.el8","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-15.el8.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.1-18.el8.ppc64le","release":"18.el8","srpm_name":"libffi","srpm_nevra":"libffi-0:3.1-18.el8.src","summary":"A portable foreign function interface library","version":"3.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.62-21.el8.ppc64le","release":"21.el8","srpm_name":"libuser","srpm_nevra":"libuser-0:0.62-21.el8.src","summary":"A user and group account administration library","version":"0.62"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.0.6-1.el8.ppc64le","release":"1.el8","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.0.6-1.el8.src","summary":"Cryptsetup shared library","version":"2.0.6"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.174-6.el8.noarch","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Default yama attach scope sysctl setting","version":"0.174"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.174-6.el8.ppc64le","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Library to read and write ELF files","version":"0.174"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.174-6.el8.ppc64le","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Libraries to handle compiled objects","version":"0.174"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.0.1763-10.el8.ppc64le","release":"10.el8","srpm_name":"vim","srpm_nevra":"vim-2:8.0.1763-10.el8.src","summary":"A minimal version of the VIM editor","version":"8.0.1763"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-2.8-5.el8.ppc64le","release":"5.el8","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:2.8-5.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.3.1-4.el8.ppc64le","release":"4.el8","srpm_name":"pam","srpm_nevra":"pam-0:1.3.1-4.el8.src","summary":"An extensible library which provides authentication for applications","version":"1.3.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.14-3.el8.ppc64le","release":"3.el8","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.14-3.el8.src","summary":"Python module to interface with ethtool","version":"0.14"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-8.2.1-3.5.el8.ppc64le","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GCC version 8 shared support library","version":"8.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-8.2.1-3.5.el8.ppc64le","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GNU Standard C++ Library","version":"8.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Partitioning library for fdisk-like programs.","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Universally unique ID library","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Formatting library for ls-like programs.","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Block device ID library","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Device mounting library","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.32.1-8.el8.ppc64le","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"A collection of basic system utilities","version":"2.32.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.4.1-1.el8.ppc64le","release":"1.el8","srpm_name":"nettle","srpm_nevra":"nettle-0:3.4.1-1.el8.src","summary":"A low-level cryptographic library","version":"3.4.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.8-13.el8.ppc64le","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Comps XML file manipulation library","version":"0.1.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.8-13.el8.ppc64le","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Python 3 bindings for libcomps library","version":"0.1.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-1.1.1-8.el8.ppc64le","release":"8.el8","srpm_name":"openssl","srpm_nevra":"openssl-1:1.1.1-8.el8.src","summary":"A general purpose cryptography library with TLS implementation","version":"1.1.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.32-1.el8.ppc64le","release":"1.el8","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.32-1.el8.src","summary":"Perl-compatible regular expression library","version":"10.32"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libssh","nvra":"libssh-0.8.5-2.el8.ppc64le","release":"2.el8","srpm_name":"libssh","srpm_nevra":"libssh-0:0.8.5-2.el8.src","summary":"A library implementing the SSH protocol","version":"0.8.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-pip","nvra":"platform-python-pip-9.0.3-13.el8.noarch","release":"13.el8","srpm_name":"python-pip","srpm_nevra":"python-pip-0:9.0.3-13.el8.src","summary":"A tool for installing and managing Python3 packages","version":"9.0.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.44.3-2.el8.ppc64le","release":"2.el8","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.44.3-2.el8.src","summary":"Common error description library","version":"1.44.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.46-9.el8.ppc64le","release":"9.el8","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.46-9.el8.src","summary":"LDAP support libraries","version":"2.4.46"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.6-7.el8.ppc64le","release":"7.el8","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.6-7.el8.src","summary":"Utilities for managing accounts and shadow password files","version":"4.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.14.2-9.el8.ppc64le","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"The RPM package management system","version":"4.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.14.2-9.el8.ppc64le","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.14.2-9.el8.ppc64le","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for building and signing RPM packages","version":"4.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.14.2-9.el8.ppc64le","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for manipulating RPM packages","version":"4.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.26.0-3.el8.ppc64le","release":"3.el8","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.26.0-3.el8.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.26.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.2.2-3.el8.noarch","release":"3.el8","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.2.2-3.el8.src","summary":"Core Plugins for DNF","version":"4.0.2.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.7.9-4.el8.ppc64le","release":"4.el8","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.7.9-4.el8.src","summary":"An alternate posix capabilities library","version":"0.7.9"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0-0.10.20180831git0047a6c.el8.ppc64le","release":"0.10.20180831git0047a6c.el8","srpm_name":"audit","srpm_nevra":"audit-0:3.0-0.10.20180831git0047a6c.el8.src","summary":"Dynamic library for libaudit","version":"3.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"curl","nvra":"curl-7.61.1-8.el8.ppc64le","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A utility for getting files from remote servers (FTP, HTTP, and others)","version":"7.61.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcurl","nvra":"libcurl-7.61.1-8.el8.ppc64le","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A library for getting files from web servers","version":"7.61.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.6.5-2.el8.ppc64le","release":"2.el8","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.6.5-2.el8.src","summary":"A TLS protocol implementation","version":"3.6.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.30-6.el8.ppc64le","release":"6.el8","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.30-6.el8.src","summary":"coreutils multicall binary","version":"8.30"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-8.2-5.el8.ppc64le","release":"5.el8","srpm_name":"gdb","srpm_nevra":"gdb-0:8.2-5.el8.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"8.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-4.4.19-7.el8.ppc64le","release":"7.el8","srpm_name":"bash","srpm_nevra":"bash-0:4.4.19-7.el8.src","summary":"The GNU Bourne Again shell","version":"4.4.19"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.56.4-1.el8.ppc64le","release":"1.el8","srpm_name":"glib2","srpm_nevra":"glib2-0:2.56.4-1.el8.src","summary":"A library of handy utility functions","version":"2.56.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.1-7.20180224.el8.noarch","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Descriptions of common terminals","version":"6.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.1-7.20180224.el8.ppc64le","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Ncurses libraries","version":"6.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libmodulemd1","nvra":"libmodulemd1-1.8.0-5.el8.ppc64le","release":"5.el8","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.0.0-5.el8.src","summary":"Compatibility package for libmodulemd 1.x","version":"1.8.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdb-utils","nvra":"libdb-utils-5.3.28-36.el8.ppc64le","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"Command line tools for managing Berkeley DB databases","version":"5.3.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-36.el8.ppc64le","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.16.1-22.el8.ppc64le","release":"22.el8","srpm_name":"krb5","srpm_nevra":"krb5-0:1.16.1-22.el8.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.16.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.6.35-6.el8.ppc64le","release":"6.el8","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.6.35-6.el8.src","summary":"Package dependency solver","version":"0.6.35"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"iptables-libs","nvra":"iptables-libs-1.8.2-9.el8.ppc64le","release":"9.el8","srpm_name":"iptables","srpm_nevra":"iptables-0:1.8.2-9.el8.src","summary":"iptables libraries","version":"1.8.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Common data and configuration files for DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Python 3 interface to DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20181217-6.git9a35207.el8.noarch","release":"6.git9a35207.el8","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20181217-6.git9a35207.el8.src","summary":"Systemwide crypto policies","version":"20181217"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.155-6.el8.ppc64le","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device-mapper shared library","version":"1.02.155"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.155-6.el8.ppc64le","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device mapper utility","version":"1.02.155"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-8.0-0.44.el8.ppc64le","release":"0.44.el8","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:8.0-0.44.el8.src","summary":"Red Hat Enterprise Linux release file","version":"8.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.23.8-35.el8.ppc64le","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Tools and libraries for subscription and repository management","version":"1.23.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-syspurpose","nvra":"python3-syspurpose-1.23.8-35.el8.ppc64le","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A commandline utility for declaring system syspurpose","version":"1.23.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dnf-plugin-subscription-manager","nvra":"dnf-plugin-subscription-manager-1.23.8-35.el8.ppc64le","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Subscription Manager plugins for DNF","version":"1.23.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.23.8-35.el8.ppc64le","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.23.8-35.el8.ppc64le","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2019a-1.el8.noarch","release":"1.el8","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2019a-1.el8.src","summary":"Timezone data","version":"2019a"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.23.14-5.el8_0.ppc64le","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.23.14"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.23.14-5.el8_0.ppc64le","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"System trust module from p11-kit","version":"0.23.14"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.28-42.el8_0.1.ppc64le","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"The GNU libc libraries","version":"2.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.28-42.el8_0.1.ppc64le","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Common binaries and locale data for glibc","version":"2.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.28-42.el8_0.1.ppc64le","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Minimal language packs for glibc.","version":"2.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.22.5-5.el8_0.ppc64le","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.22.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.22.5-5.el8_0.ppc64le","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.22.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.22.5-5.el8_0.ppc64le","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.22.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-25-11.el8_0.2.ppc64le","release":"11.el8_0.2","srpm_name":"kmod","srpm_nevra":"kmod-0:25-11.el8_0.2.src","summary":"Libraries to handle kernel module loading and unloading","version":"25"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"platform-python","nvra":"platform-python-3.6.8-2.el8_0.ppc64le","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Internal interpreter of the Python programming language","version":"3.6.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.6.8-2.el8_0.ppc64le","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Python runtime libraries","version":"3.6.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-239-13.el8_0.3.ppc64le","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd libraries","version":"239"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-239-13.el8_0.3.ppc64le","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd PAM module","version":"239"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-239-13.el8_0.3.ppc64le","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"System and Service Manager","version":"239"}],"_links":{"image":{"href":"/v1/images/id/5cc9ca42dd19c7782937e032"}}} +-- catalog.redhat.com/api/containers/v1/images/id/5cc9ca44dd19c7782937e03e/rpm-manifest -- +{"_id":"5cc9ca45dd19c7782937e044","creation_date":"2019-05-01T16:33:09.438000+00:00","image_id":"5cc9ca44dd19c7782937e03e","last_update_date":"2024-09-06T10:10:06.557000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.1.1-4.el8.s390x","release":"4.el8","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.1.1-4.el8.src","summary":"Extended crypt library for DES, MD5, Blowfish and others","version":"4.1.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.1-6.el8.s390x","release":"6.el8","srpm_name":"grep","srpm_nevra":"grep-0:3.1-6.el8.src","summary":"Pattern matching utilities","version":"3.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.3.4-10.el8.s390x","release":"10.el8","srpm_name":"lua","srpm_nevra":"lua-0:5.3.4-10.el8.src","summary":"Libraries for lua","version":"5.3.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-10.el8.s390x","release":"10.el8","srpm_name":"which","srpm_nevra":"which-0:2.21-10.el8.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.9-4.el8.s390x","release":"4.el8","srpm_name":"gzip","srpm_nevra":"gzip-0:1.9-4.el8.src","summary":"The GNU data compression program","version":"1.9"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.6-26.el8.s390x","release":"26.el8","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.6-26.el8.src","summary":"Libraries for applications using bzip2","version":"1.0.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.5-1.el8.s390x","release":"1.el8","srpm_name":"sed","srpm_nevra":"sed-0:4.5-1.el8.src","summary":"A GNU stream text editor","version":"4.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.30-4.el8.s390x","release":"4.el8","srpm_name":"tar","srpm_nevra":"tar-2:1.30-4.el8.src","summary":"A GNU file archiving program","version":"1.30"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-4.2.1-1.el8.s390x","release":"1.el8","srpm_name":"gawk","srpm_nevra":"gawk-0:4.2.1-1.el8.src","summary":"The GNU version of the AWK text processing utility","version":"4.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-5.el8.noarch","release":"5.el8","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-5.el8.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.2.53-1.el8.s390x","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Dynamic library for access control list support","version":"2.2.53"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.2.53-1.el8.s390x","release":"1.el8","srpm_name":"acl","srpm_nevra":"acl-0:2.2.53-1.el8.src","summary":"Access control list utilities","version":"2.2.53"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.4.48-3.el8.s390x","release":"3.el8","srpm_name":"attr","srpm_nevra":"attr-0:2.4.48-3.el8.src","summary":"Dynamic library for extended attribute support","version":"2.4.48"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-0.3rc7.el8.s390x","release":"0.3rc7.el8","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-0.3rc7.el8.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-glib","nvra":"dbus-glib-0.110-2.el8.s390x","release":"2.el8","srpm_name":"dbus-glib","srpm_nevra":"dbus-glib-0:0.110-2.el8.src","summary":"GLib bindings for D-Bus","version":"0.110"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.4-14.el8.s390x","release":"14.el8","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.4-14.el8.src","summary":"D-Bus bindings for python3","version":"1.2.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.8-2.el8.s390x","release":"2.el8","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.8-2.el8.src","summary":"The basic directory layout for a Linux system","version":"3.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.5-3.el8.s390x","release":"3.el8","srpm_name":"expat","srpm_nevra":"expat-0:2.2.5-3.el8.src","summary":"An XML parser library","version":"2.2.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.7-5.el8.s390x","release":"5.el8","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.7-5.el8.src","summary":"Library providing XML and HTML support","version":"2.9.7"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.1.2-8.el8.s390x","release":"8.el8","srpm_name":"gmp","srpm_nevra":"gmp-1:6.1.2-8.el8.src","summary":"A GNU arbitrary precision library","version":"6.1.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.2.1-2.el8.noarch","release":"2.el8","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.2.1-2.el8.src","summary":"Module to simplify usage of decorators in python3","version":"4.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.56.1-1.el8.s390x","release":"1.el8","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.56.1-1.el8.src","summary":"Introspection system for GObject-based libraries","version":"1.56.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-1.0-12.el8.noarch","release":"12.el8","srpm_name":"langpacks","srpm_nevra":"langpacks-0:1.0-12.el8.src","summary":"English langpacks meta-package","version":"1.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.6.1-6.el8.noarch","release":"6.el8","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.6.1-6.el8.src","summary":"Powerful extensions to the standard datetime module","version":"2.6.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.2.9-1.el8.s390x","release":"1.el8","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.2.9-1.el8.src","summary":"Utility for secure communication and data storage","version":"2.2.9"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-31.el8.noarch","release":"31.el8","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-31.el8.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.13.1-0.2.el8.s390x","release":"0.2.el8","srpm_name":"json-c","srpm_nevra":"json-c-0:0.13.1-0.2.el8.src","summary":"JSON implementation in C","version":"0.13.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.5.10-6.el8.s390x","release":"6.el8","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.5.10-6.el8.src","summary":"Key utilities library","version":"1.5.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.1-3.el8.s390x","release":"3.el8","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.1-3.el8.src","summary":"GnuPG IPC library","version":"2.5.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.25-9.el8.s390x","release":"9.el8","srpm_name":"libcap","srpm_nevra":"libcap-0:2.25-9.el8.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.25"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.31-1.el8.s390x","release":"1.el8","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.31-1.el8.src","summary":"Library for error values used by GnuPG components","version":"1.31"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.8.3-2.el8.s390x","release":"2.el8","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.8.3-2.el8.src","summary":"A general-purpose cryptography library","version":"1.8.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.0.5-1.el8.s390x","release":"1.el8","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.0.5-1.el8.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.0.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libmetalink","nvra":"libmetalink-0.1.3-7.el8.s390x","release":"7.el8","srpm_name":"libmetalink","srpm_nevra":"libmetalink-0:0.1.3-7.el8.src","summary":"Metalink library written in C","version":"0.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.3.5-7.el8.s390x","release":"7.el8","srpm_name":"libksba","srpm_nevra":"libksba-0:1.3.5-7.el8.src","summary":"CMS and X.509 library","version":"1.3.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.3.2-3.el8.s390x","release":"3.el8","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.3.2-3.el8.src","summary":"A library for handling streaming archive formats","version":"3.3.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libnsl2","nvra":"libnsl2-1.2.0-2.20180605git4a062cf.el8.s390x","release":"2.20180605git4a062cf.el8","srpm_name":"libnsl2","srpm_nevra":"libnsl2-0:1.2.0-2.20180605git4a062cf.el8.src","summary":"Public client interface library for NIS(YP) and NIS+","version":"1.2.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.4.0-4.el8.s390x","release":"4.el8","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.4.0-4.el8.src","summary":"Convenience library for kernel netlink sockets","version":"3.4.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libpsl","nvra":"libpsl-0.20.2-5.el8.s390x","release":"5.el8","srpm_name":"libpsl","srpm_nevra":"libpsl-0:0.20.2-5.el8.src","summary":"C library for the Publix Suffix List","version":"0.20.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libpcap","nvra":"libpcap-1.9.0-1.el8.s390x","release":"1.el8","srpm_name":"libpcap","srpm_nevra":"libpcap-14:1.9.0-1.el8.src","summary":"A system-independent interface for user-level packet capture","version":"1.9.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.11-5.el8.s390x","release":"5.el8","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.11-5.el8.src","summary":"Library for handling page faults in user mode","version":"2.11"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.3.3-3.el8.s390x","release":"3.el8","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.3.3-3.el8.src","summary":"Enhanced seccomp library","version":"2.3.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.13-3.el8.s390x","release":"3.el8","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.13-3.el8.src","summary":"The ASN.1 library used in GNUTLS","version":"4.13"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.1.6-14.el8.s390x","release":"14.el8","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.1.6-14.el8.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.1.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.0-5.el8.s390x","release":"5.el8","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.0-5.el8.src","summary":"Main loop abstraction library","version":"0.3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.11.0-8.el8.noarch","release":"8.el8","srpm_name":"python-six","srpm_nevra":"python-six-0:1.11.0-8.el8.src","summary":"Python 2 and 3 compatibility utilities","version":"1.11.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.1.7-5.el8.s390x","release":"5.el8","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.1.7-5.el8.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.1.7"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.8.1.2-4.el8.s390x","release":"4.el8","srpm_name":"lz4","srpm_nevra":"lz4-0:1.8.1.2-4.el8.src","summary":"Libaries for lz4","version":"1.8.1.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-3.1.6-1.el8.s390x","release":"1.el8","srpm_name":"mpfr","srpm_nevra":"mpfr-0:3.1.6-1.el8.src","summary":"A C library for multiple-precision floating-point computations","version":"3.1.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.5-4.el8.s390x","release":"4.el8","srpm_name":"npth","srpm_nevra":"npth-0:1.5-4.el8.src","summary":"The New GNU Portable Threads library","version":"1.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"publicsuffix-list-dafsa","nvra":"publicsuffix-list-dafsa-20180723-1.el8.noarch","release":"1.el8","srpm_name":"publicsuffix-list","srpm_nevra":"publicsuffix-list-0:20180723-1.el8.src","summary":"Cross-vendor public domain suffix database in DAFSA form","version":"20180723"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-2.el8.s390x","release":"2.el8","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-2.el8.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-10.el8.s390x","release":"10.el8","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-10.el8.src","summary":"The compression and decompression library","version":"1.2.11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pkgconf-m4","nvra":"pkgconf-m4-1.4.2-1.el8.noarch","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"m4 macros for pkgconf","version":"1.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pkgconf","nvra":"pkgconf-1.4.2-1.el8.s390x","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Package compiler and linker metadata toolkit","version":"1.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pkgconf-pkg-config","nvra":"pkgconf-pkg-config-1.4.2-1.el8.s390x","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"pkgconf shim to provide /usr/bin/pkg-config","version":"1.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libpkgconf","nvra":"libpkgconf-1.4.2-1.el8.s390x","release":"1.el8","srpm_name":"pkgconf","srpm_nevra":"pkgconf-0:1.4.2-1.el8.src","summary":"Backend library for pkgconf","version":"1.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.16-14.el8.s390x","release":"14.el8","srpm_name":"popt","srpm_nevra":"popt-0:1.16-14.el8.src","summary":"C library for parsing command line parameters","version":"1.16"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.28.3-1.el8.s390x","release":"1.el8","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.28.3-1.el8.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.28.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-7.0-10.el8.s390x","release":"10.el8","srpm_name":"readline","srpm_nevra":"readline-0:7.0-10.el8.src","summary":"A library for editing typed command lines","version":"7.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2018.2.24-6.el8.noarch","release":"6.el8","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2018.2.24-6.el8.src","summary":"The Mozilla CA root certificate bundle","version":"2018.2.24"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.9-3.el8.s390x","release":"3.el8","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.9-3.el8.src","summary":"GNU Unicode string library","version":"0.9.9"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libusbx","nvra":"libusbx-1.0.22-1.el8.s390x","release":"1.el8","srpm_name":"libusbx","srpm_nevra":"libusbx-0:1.0.22-1.el8.src","summary":"Library for accessing USB devices","version":"1.0.22"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.9.5-6.el8.s390x","release":"6.el8","srpm_name":"libreport","srpm_nevra":"libreport-0:2.9.5-6.el8.src","summary":"Filesystem layout for libreport","version":"2.9.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.42-4.el8.s390x","release":"4.el8","srpm_name":"pcre","srpm_nevra":"pcre-0:8.42-4.el8.src","summary":"Perl-compatible regular expression library","version":"8.42"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.12.2-1.el8.noarch","release":"1.el8","srpm_name":"setup","srpm_nevra":"setup-0:2.12.2-1.el8.src","summary":"A set of system configuration and setup files","version":"2.12.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"chkconfig","nvra":"chkconfig-1.11-1.el8.s390x","release":"1.el8","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.11-1.el8.src","summary":"A system tool for maintaining the /etc/rc*.d hierarchy","version":"1.11"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.9.2-1.el8.s390x","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Repodata downloading library","version":"1.9.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.9.2-1.el8.s390x","release":"1.el8","srpm_name":"librepo","srpm_nevra":"librepo-0:1.9.2-1.el8.src","summary":"Python 3 bindings for the librepo library","version":"1.9.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.18-1.el8.s390x","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"Libraries files for gdbm","version":"1.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gdbm","nvra":"gdbm-1.18-1.el8.s390x","release":"1.el8","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.18-1.el8.src","summary":"A GNU set of database routines which use extensible hashing","version":"1.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libtirpc","nvra":"libtirpc-1.1.4-3.el8.s390x","release":"3.el8","srpm_name":"libtirpc","srpm_nevra":"libtirpc-0:1.1.4-3.el8.src","summary":"Transport Independent RPC Library","version":"1.1.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"info","nvra":"info-6.5-4.el8.s390x","release":"4.el8","srpm_name":"texinfo","srpm_nevra":"texinfo-0:6.5-4.el8.src","summary":"A stand-alone TTY-based reader for GNU texinfo documentation","version":"6.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.33.0-1.el8.s390x","release":"1.el8","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.33.0-1.el8.src","summary":"A library implementing the HTTP/2 protocol","version":"1.33.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"brotli","nvra":"brotli-1.0.6-1.el8.s390x","release":"1.el8","srpm_name":"brotli","srpm_nevra":"brotli-0:1.0.6-1.el8.src","summary":"Lossless compression algorithm","version":"1.0.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.4.4-1.el8.s390x","release":"1.el8","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.4.4-1.el8.src","summary":"Library for JavaScript Object Notation format","version":"1.4.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.0-9.el8.s390x","release":"9.el8","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.0-9.el8.src","summary":"A library for password generation and password quality checking","version":"1.4.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.8-7.el8.noarch","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus configuration","version":"1.12.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-daemon","nvra":"dbus-daemon-1.12.8-7.el8.s390x","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-tools","nvra":"dbus-tools-1.12.8-7.el8.s390x","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS Tools and Utilities","version":"1.12.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.8-7.el8.s390x","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"D-BUS message bus","version":"1.12.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.8-7.el8.s390x","release":"7.el8","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.8-7.el8.src","summary":"Libraries for accessing D-BUS","version":"1.12.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-setuptools","nvra":"platform-python-setuptools-39.2.0-4.el8.noarch","release":"4.el8","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:39.2.0-4.el8.src","summary":"Easily build and distribute Python 3 packages","version":"39.2.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.1-4.el8.s390x","release":"4.el8","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.1-4.el8.src","summary":"IMA/EVM support utilities","version":"1.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.18-6.el8.s390x","release":"6.el8","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.18-6.el8.src","summary":"Detect if we are running in a virtual machine","version":"1.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.6.0-20.el8.s390x","release":"20.el8","srpm_name":"findutils","srpm_nevra":"findutils-1:4.6.0-20.el8.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.6.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.33-8.el8.s390x","release":"8.el8","srpm_name":"file","srpm_nevra":"file-0:5.33-8.el8.src","summary":"Libraries for applications using libmagic","version":"5.33"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-2.8-2.el8.s390x","release":"2.el8","srpm_name":"libsepol","srpm_nevra":"libsepol-0:2.8-2.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-2.8-6.el8.s390x","release":"6.el8","srpm_name":"libselinux","srpm_nevra":"libselinux-0:2.8-6.el8.src","summary":"SELinux library and simple utilities","version":"2.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-2.el8.s390x","release":"2.el8","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-2.el8.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-13.el8.noarch","release":"13.el8","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-13.el8.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.113-1.el8.s390x","release":"1.el8","srpm_name":"usermode","srpm_nevra":"usermode-0:1.113-1.el8.src","summary":"Tools for certain user account management tasks","version":"1.113"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.10.0-6.el8.s390x","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.10.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.10.0-6.el8.s390x","release":"6.el8","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.10.0-6.el8.src","summary":"gpgme bindings for Python 3","version":"1.10.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.4-3.el8.s390x","release":"3.el8","srpm_name":"xz","srpm_nevra":"xz-0:5.2.4-3.el8.src","summary":"Libraries for decoding LZMA compression","version":"5.2.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-15.el8.s390x","release":"15.el8","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-15.el8.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.1-18.el8.s390x","release":"18.el8","srpm_name":"libffi","srpm_nevra":"libffi-0:3.1-18.el8.src","summary":"A portable foreign function interface library","version":"3.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.62-21.el8.s390x","release":"21.el8","srpm_name":"libuser","srpm_nevra":"libuser-0:0.62-21.el8.src","summary":"A user and group account administration library","version":"0.62"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.0.6-1.el8.s390x","release":"1.el8","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.0.6-1.el8.src","summary":"Cryptsetup shared library","version":"2.0.6"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.174-6.el8.noarch","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Default yama attach scope sysctl setting","version":"0.174"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.174-6.el8.s390x","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Library to read and write ELF files","version":"0.174"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.174-6.el8.s390x","release":"6.el8","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.174-6.el8.src","summary":"Libraries to handle compiled objects","version":"0.174"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.0.1763-10.el8.s390x","release":"10.el8","srpm_name":"vim","srpm_nevra":"vim-2:8.0.1763-10.el8.src","summary":"A minimal version of the VIM editor","version":"8.0.1763"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-2.8-5.el8.s390x","release":"5.el8","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:2.8-5.el8.src","summary":"SELinux binary policy manipulation library","version":"2.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.3.1-4.el8.s390x","release":"4.el8","srpm_name":"pam","srpm_nevra":"pam-0:1.3.1-4.el8.src","summary":"An extensible library which provides authentication for applications","version":"1.3.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.14-3.el8.s390x","release":"3.el8","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.14-3.el8.src","summary":"Python module to interface with ethtool","version":"0.14"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-8.2.1-3.5.el8.s390x","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GCC version 8 shared support library","version":"8.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-8.2.1-3.5.el8.s390x","release":"3.5.el8","srpm_name":"gcc","srpm_nevra":"gcc-0:8.2.1-3.5.el8.src","summary":"GNU Standard C++ Library","version":"8.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Universally unique ID library","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"A collection of basic system utilities","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Partitioning library for fdisk-like programs.","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Block device ID library","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Device mounting library","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.32.1-8.el8.s390x","release":"8.el8","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.32.1-8.el8.src","summary":"Formatting library for ls-like programs.","version":"2.32.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.4.1-1.el8.s390x","release":"1.el8","srpm_name":"nettle","srpm_nevra":"nettle-0:3.4.1-1.el8.src","summary":"A low-level cryptographic library","version":"3.4.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.8-13.el8.s390x","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Python 3 bindings for libcomps library","version":"0.1.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.8-13.el8.s390x","release":"13.el8","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.8-13.el8.src","summary":"Comps XML file manipulation library","version":"0.1.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-1.1.1-8.el8.s390x","release":"8.el8","srpm_name":"openssl","srpm_nevra":"openssl-1:1.1.1-8.el8.src","summary":"A general purpose cryptography library with TLS implementation","version":"1.1.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.32-1.el8.s390x","release":"1.el8","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.32-1.el8.src","summary":"Perl-compatible regular expression library","version":"10.32"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libssh","nvra":"libssh-0.8.5-2.el8.s390x","release":"2.el8","srpm_name":"libssh","srpm_nevra":"libssh-0:0.8.5-2.el8.src","summary":"A library implementing the SSH protocol","version":"0.8.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"platform-python-pip","nvra":"platform-python-pip-9.0.3-13.el8.noarch","release":"13.el8","srpm_name":"python-pip","srpm_nevra":"python-pip-0:9.0.3-13.el8.src","summary":"A tool for installing and managing Python3 packages","version":"9.0.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.44.3-2.el8.s390x","release":"2.el8","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.44.3-2.el8.src","summary":"Common error description library","version":"1.44.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.46-9.el8.s390x","release":"9.el8","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.46-9.el8.src","summary":"LDAP support libraries","version":"2.4.46"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.6-7.el8.s390x","release":"7.el8","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.6-7.el8.src","summary":"Utilities for managing accounts and shadow password files","version":"4.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.14.2-9.el8.s390x","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for building and signing RPM packages","version":"4.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.14.2-9.el8.s390x","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Libraries for manipulating RPM packages","version":"4.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.14.2-9.el8.s390x","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"The RPM package management system","version":"4.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.14.2-9.el8.s390x","release":"9.el8","srpm_name":"rpm","srpm_nevra":"rpm-0:4.14.2-9.el8.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.26.0-3.el8.s390x","release":"3.el8","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.26.0-3.el8.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.26.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.2.2-3.el8.noarch","release":"3.el8","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.2.2-3.el8.src","summary":"Core Plugins for DNF","version":"4.0.2.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.7.9-4.el8.s390x","release":"4.el8","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.7.9-4.el8.src","summary":"An alternate posix capabilities library","version":"0.7.9"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0-0.10.20180831git0047a6c.el8.s390x","release":"0.10.20180831git0047a6c.el8","srpm_name":"audit","srpm_nevra":"audit-0:3.0-0.10.20180831git0047a6c.el8.src","summary":"Dynamic library for libaudit","version":"3.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcurl","nvra":"libcurl-7.61.1-8.el8.s390x","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A library for getting files from web servers","version":"7.61.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"curl","nvra":"curl-7.61.1-8.el8.s390x","release":"8.el8","srpm_name":"curl","srpm_nevra":"curl-0:7.61.1-8.el8.src","summary":"A utility for getting files from remote servers (FTP, HTTP, and others)","version":"7.61.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.6.5-2.el8.s390x","release":"2.el8","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.6.5-2.el8.src","summary":"A TLS protocol implementation","version":"3.6.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.30-6.el8.s390x","release":"6.el8","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.30-6.el8.src","summary":"coreutils multicall binary","version":"8.30"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-8.2-5.el8.s390x","release":"5.el8","srpm_name":"gdb","srpm_nevra":"gdb-0:8.2-5.el8.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"8.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-4.4.19-7.el8.s390x","release":"7.el8","srpm_name":"bash","srpm_nevra":"bash-0:4.4.19-7.el8.src","summary":"The GNU Bourne Again shell","version":"4.4.19"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.56.4-1.el8.s390x","release":"1.el8","srpm_name":"glib2","srpm_nevra":"glib2-0:2.56.4-1.el8.src","summary":"A library of handy utility functions","version":"2.56.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.1-7.20180224.el8.noarch","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Descriptions of common terminals","version":"6.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.1-7.20180224.el8.s390x","release":"7.20180224.el8","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.1-7.20180224.el8.src","summary":"Ncurses libraries","version":"6.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libmodulemd1","nvra":"libmodulemd1-1.8.0-5.el8.s390x","release":"5.el8","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.0.0-5.el8.src","summary":"Compatibility package for libmodulemd 1.x","version":"1.8.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdb-utils","nvra":"libdb-utils-5.3.28-36.el8.s390x","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"Command line tools for managing Berkeley DB databases","version":"5.3.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-36.el8.s390x","release":"36.el8","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-36.el8.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.16.1-22.el8.s390x","release":"22.el8","srpm_name":"krb5","srpm_nevra":"krb5-0:1.16.1-22.el8.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.16.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.6.35-6.el8.s390x","release":"6.el8","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.6.35-6.el8.src","summary":"Package dependency solver","version":"0.6.35"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"iptables-libs","nvra":"iptables-libs-1.8.2-9.el8.s390x","release":"9.el8","srpm_name":"iptables","srpm_nevra":"iptables-0:1.8.2-9.el8.src","summary":"iptables libraries","version":"1.8.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Common data and configuration files for DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Python 3 interface to DNF","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.0.9.2-5.el8.noarch","release":"5.el8","srpm_name":"dnf","srpm_nevra":"dnf-0:4.0.9.2-5.el8.src","summary":"Package manager","version":"4.0.9.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20181217-6.git9a35207.el8.noarch","release":"6.git9a35207.el8","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20181217-6.git9a35207.el8.src","summary":"Systemwide crypto policies","version":"20181217"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.155-6.el8.s390x","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device mapper utility","version":"1.02.155"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.155-6.el8.s390x","release":"6.el8","srpm_name":"lvm2","srpm_nevra":"lvm2-8:2.03.02-6.el8.src","summary":"Device-mapper shared library","version":"1.02.155"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-8.0-0.44.el8.s390x","release":"0.44.el8","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:8.0-0.44.el8.src","summary":"Red Hat Enterprise Linux release file","version":"8.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.23.8-35.el8.s390x","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Tools and libraries for subscription and repository management","version":"1.23.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dnf-plugin-subscription-manager","nvra":"dnf-plugin-subscription-manager-1.23.8-35.el8.s390x","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Subscription Manager plugins for DNF","version":"1.23.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.23.8-35.el8.s390x","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-syspurpose","nvra":"python3-syspurpose-1.23.8-35.el8.s390x","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"A commandline utility for declaring system syspurpose","version":"1.23.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.23.8-35.el8.s390x","release":"35.el8","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.23.8-35.el8.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.23.8"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2019a-1.el8.noarch","release":"1.el8","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2019a-1.el8.src","summary":"Timezone data","version":"2019a"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.23.14-5.el8_0.s390x","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.23.14"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.23.14-5.el8_0.s390x","release":"5.el8_0","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.23.14-5.el8_0.src","summary":"System trust module from p11-kit","version":"0.23.14"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.28-42.el8_0.1.s390x","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Common binaries and locale data for glibc","version":"2.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.28-42.el8_0.1.s390x","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"Minimal language packs for glibc.","version":"2.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.28-42.el8_0.1.s390x","release":"42.el8_0.1","srpm_name":"glibc","srpm_nevra":"glibc-0:2.28-42.el8_0.1.src","summary":"The GNU libc libraries","version":"2.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.22.5-5.el8_0.s390x","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.22.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.22.5-5.el8_0.s390x","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.22.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.22.5-5.el8_0.s390x","release":"5.el8_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.22.5-5.el8_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.22.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-25-11.el8_0.2.s390x","release":"11.el8_0.2","srpm_name":"kmod","srpm_nevra":"kmod-0:25-11.el8_0.2.src","summary":"Libraries to handle kernel module loading and unloading","version":"25"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.6.8-2.el8_0.s390x","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Python runtime libraries","version":"3.6.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"platform-python","nvra":"platform-python-3.6.8-2.el8_0.s390x","release":"2.el8_0","srpm_name":"python3","srpm_nevra":"python3-0:3.6.8-2.el8_0.src","summary":"Internal interpreter of the Python programming language","version":"3.6.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-239-13.el8_0.3.s390x","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"System and Service Manager","version":"239"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-239-13.el8_0.3.s390x","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd libraries","version":"239"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-239-13.el8_0.3.s390x","release":"13.el8_0.3","srpm_name":"systemd","srpm_nevra":"systemd-0:239-13.el8_0.3.src","summary":"systemd PAM module","version":"239"}],"_links":{"image":{"href":"/v1/images/id/5cc9ca44dd19c7782937e03e"}}} diff --git a/rhel/testdata/package/ubi9_httpd-24.txtar b/rhel/testdata/package/ubi9_httpd-24.txtar new file mode 100644 index 000000000..2dd3f0677 --- /dev/null +++ b/rhel/testdata/package/ubi9_httpd-24.txtar @@ -0,0 +1,26 @@ +Generator: fetch-container-rpm-manifest +Version: (devel) +Created: 2025-05-13T15:03:42-05:00 +Search-Term: repository:ubi9/httpd-24 +Url: https://access.redhat.com/hydra/rest/search/kcs?fl=id%2Crepository%2Cregistry%2Cparsed_data_layers&fq=documentKind%3A%22ContainerRepository%22&fq=-eol_date%3A%5B%2A+TO+NOW%5D&fq=repository%3Aubi9%2Fhttpd-24&q=%2A&redhat_client=claircore%2Ffetch-container-rpm-manifest&rows=10 +Url: https://catalog.redhat.com/api/containers/v1/repositories/id/61a60c3e3e9240fca360f74a +Url: https://catalog.redhat.com/api/containers/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/httpd-24/images?exclude=data.brew%2Cdata.certified%2Cdata.container_grades%2Cdata.content_sets%2Cdata.cpe_ids%2Cdata.docker_image_id%2Cdata.freshness_grades%2Cdata.parsed_data.command%2Cdata.parsed_data.comment%2Cdata.parsed_data.docker_version%2Cdata.parsed_data.env_variables%2Cdata.parsed_data.labels%2Cdata.parsed_data.ports%2Cdata.parsed_data.size%2Cdata.parsed_data.uncompressed_size_bytes%2Cdata.parsed_data.user%2Cdata.raw_config%2Cdata.repositories%2Cdata.sum_layer_size_bytes%2Cdata.top_layer_id%2Cdata.uncompressed_top_layer_id&filter=deleted%21%3Dtrue&page=0&page_size=6&sort_by=creation_date%5Basc%5D +Url: https://catalog.redhat.com/api/containers/v1/images/id/6272a08c4841f16f4f118c5c/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/6272a08f4841f16f4f118c60/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/6272a0924841f16f4f118c66/rpm-manifest +Url: https://catalog.redhat.com/api/containers/v1/images/id/6272a0954841f16f4f118c6a/rpm-manifest + +-- access.redhat.com/hydra/rest/search/kcs -- +{"spellcheck":{"collations":[],"suggestions":[]},"response":{"docs":[{"parsed_data_layers":["sha256:5741b6a86ae0ad6db4fe34b04f060787e82f7a7c3d0a2fe24de05ec0e6aa2c88","sha256:29afda33dcdfc3ac6d0fdb21505a42271b92572ccfab6e5c5a0ea333b48c7ee6","sha256:99814ff0874a99ca8fdc4d488a2c9ede239356628b3a84decfb86fa866af785c"],"registry":"registry.access.redhat.com","id":"61a60c3e3e9240fca360f74a","repository":"ubi9/httpd-24"}],"numFound":1,"start":0,"maxScore":2,"numFoundExact":true},"responseHeader":{"QTime":35,"zkConnected":true,"params":{"ps":"3","bf":"if(exists(pulls_in_last_30_days),sqrt(log(map(pulls_in_last_30_days,0,0,1))),1)","fl":"id,repository,registry,parsed_data_layers","q.op":"AND","fq":["documentKind:\"ContainerRepository\"","-eol_date:[* TO NOW]","repository:ubi9/httpd-24"," -documentKind:( ApplicationAttribute )","-accessState:(private OR retired) AND -hasPublishedRevision:false","-doNotDisplay:true"],"isAuthenticated":"false","ps2":"3","q.orig":"*","ps3":"3","defType":"edismax","spellcheck.q":"*","trace":["host: restprod04","method: GET","uri: /rs/search","route: portal","collection: access"],"redhat_client":"claircore/fetch-container-rpm-manifest","qf":"psfa^10.0 psfb^5.5 psfc^4.5 psfd^3.5 psfe^4.0 psff^2.5 psfg^2.0","matchtype":"exact","hl.fl":"abstract","wt":"json","mm":"0","start":"0","sort":"score desc,id asc","rows":"10","reqId":"ID-hydra-search-api-prod-57-djshx-1747148834692-0-114310","isInternal":"false","q":"*","enableElevation":"true","spellcheck":"true","pf":"psfa^12.0 psfb^5.0 psfc^4.0 psfd^3.5 psfe^4.0 psff^2.5 psfg^2.0","boost":["map(query({!field f='view_uri' v='https://access.redhat.com/downloads/content/package-browser'}), 0, 0, 1, 260.64342)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/8409'}), 0, 0, 1, 124.98317)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/914003'}), 0, 0, 1, 122.75514)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/29036'}), 0, 0, 1, 121.28655)","map(query({!field f='view_uri' v='https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/considerations_in_adopting_rhel_9/'}), 0, 0, 1, 105.7091)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/1378093'}), 0, 0, 1, 82.3566)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/4078831'}), 0, 0, 1, 79.10734)","map(query({!field f='view_uri' v='https://access.redhat.com/discussions/4311201'}), 0, 0, 1, 63.29097)","map(query({!field f='view_uri' v='https://access.redhat.com/articles/simple-content-access'}), 0, 0, 1, 60.65626)","map(query({!field f='view_uri' v='https://access.redhat.com/solutions/17215'}), 0, 0, 1, 58.7909)"],"showRetired":"false","pf3":"psfa^7.0 psfb^3.0 psfc^3.5 psfd^2.5 psfe^2.5 psff^1.0 psfg^1.0","pf2":"psfa^2.0 psfb^1.5 psfc^1.0 psfd^1.0 psfe^1.5 psff^1.0 psfg^1.0"},"status":0}} +-- catalog.redhat.com/api/containers/v1/repositories/id/61a60c3e3e9240fca360f74a -- +{"_id":"61a60c3e3e9240fca360f74a","application_categories":["Programming Languages & Runtimes"],"auto_rebuild_tags":[],"build_categories":["Builder image"],"can_auto_release_cve_rebuild":false,"content_stream_grades":[{"grade":"A","image_ids":[{"arch":"amd64","id":"6811ed5934db2eef54d303af"},{"arch":"arm64","id":"6811ed7187e6041475183208"},{"arch":"s390x","id":"6811ed901262d0c8c55d5a38"},{"arch":"ppc64le","id":"6811eda5f254c8a343814afd"}],"tag":"latest"}],"content_stream_tags":["latest"],"creation_date":"2021-11-30T11:34:22.640000+00:00","display_data":{"long_description":"Apache HTTP Server 2.4 available as container, is a powerful, efficient, and extensible web server. Apache supports a variety of features, many implemented as compiled modules which extend the core functionality. These can range from server-side programming language support to authentication schemes. Virtual hosting allows one Apache installation to serve many different Web sites."
In this example, we assume that you are using the ubi9/httpd-24 image, available through the httpd:24 imagestream tag in Openshift.
To build a simple httpd-sample-app application in Openshift:
oc new-app httpd:24~https://github.com/sclorg/httpd-ex.git
To access the application:
$ oc get pods
$ oc exec <pod> -- curl 127.0.0.1:8080
This image supports the Source-to-Image (S2I) strategy in OpenShift. The Source-to-Image is an OpenShift framework which makes it easy to write images that take application source code as an input, use a builder image like this httpd container image, and produce a new image that runs the assembled application as an output.
To support the Source-to-Image framework, important scripts are included in the builder image:
The /usr/libexec/s2i/run script is set as the default command in the resulting container image (the new image with the application artifacts).
The /usr/libexec/s2i/assemble script inside the image is run to produce a new image with the application artifacts. The script takes sources of a given application and places them into appropriate directories inside the image. The structure of httpd-app can look like this:
./httpd-cfg
Can contain additional Apache configuration files (*.conf)
./httpd-pre-init
Can contain shell scripts (*.sh) that are sourced before httpd is started
./httpd-ssl
Can contain user's own SSL certificate (in the certs/ subdirectory) and a key (in the private/ subdirectory)
./
Application source code
Compared to the Source-to-Image strategy, using a Dockerfile is a more flexible way to build an httpd container image with an application. Use a Dockerfile when Source-to-Image is not sufficiently flexible for you or when you build the image outside of the OpenShift environment.
To use the httpd image in a Dockerfile, follow these steps:
podman pull ubi9/httpd-24
An example application available at https://github.com/sclorg/httpd-ex.git is used here. To adjust the example application, clone the repository.
git clone https://github.com/sclorg/httpd-ex.git app-src
This step usually consists of at least these parts:
For all these three parts, you can either set up all manually and use the httpd or run-httpd commands explicitly in the Dockerfile (3.1.), or you can use the Source-to-Image scripts inside the image (3.2.. For more information about these scripts, which enable you to set-up and run the httpd daemon, see the "Source-to-Image framework and scripts" section above.
FROM registry.redhat.io/ubi9/httpd-24
# Add application sources
ADD app-src/index.html /var/www/html/index.html
# The run script uses standard ways to run the application
CMD run-httpd
FROM registry.redhat.io/ubi9/httpd-24
# Add application sources to a directory where the assemble script expects them
# and set permissions so that the container runs without the root access
USER 0
ADD app-src/index.html /tmp/src/index.html
RUN chown -R 1001:0 /tmp/src
USER 1001
# Let the assemble script install the dependencies
RUN /usr/libexec/s2i/assemble
# The run script uses standard ways to run the application
CMD /usr/libexec/s2i/run
podman build -t httpd-app .
podman run -d httpd-app
An example of the data on the host for both the examples above, which is served by The Apache HTTP web server:
$ ls -lZ /wwwdata/html
-rw-r--r--. 1 1001 1001 54321 Jan 01 12:34 index.html
-rw-r--r--. 1 1001 1001 5678 Jan 01 12:34 page.html
If you want to run the image directly and mount the static pages available in the /wwwdata/ directory on the host
as a container volume, execute the following command:
$ podman run -d --name httpd -p 8080:8080 -v /wwwdata:/var/www:Z ubi9/httpd-24
This creates a container named httpd running the Apache HTTP Server, serving data from
the /wwwdata/ directory. Port 8080 is exposed and mapped to the host.
The Apache HTTP Server container image supports the following configuration variable, which can be set by using the -e option with the podman run command:
HTTPD_LOG_TO_VOLUME
By default, httpd logs into standard output, so the logs are accessible by using the podman logs command. When HTTPD_LOG_TO_VOLUME is set, httpd logs into /var/log/httpd24, which can be mounted to host system using the container volumes. This option is only allowed when container is run as UID 0.
HTTPD_MPM
The variable HTTPD_MPM can be set to change the default Multi-Processing Module (MPM) from the package default MPM.
If you want to run the image and mount the log files into /wwwlogs on the host
as a container volume, execute the following command:
$ podman run -d -u 0 -e HTTPD_LOG_TO_VOLUME=1 --name httpd -v /wwwlogs:/var/log/httpd24:Z ubi9/httpd-24
To run an image using the event MPM (rather than the default prefork), execute the following command:
$ podman run -d -e HTTPD_MPM=event --name httpd ubi9/httpd-24
You can also set the following mount points by passing the -v /host:/container flag to podman.
/var/www
Apache HTTP Server data directory
/var/log/httpd24
Apache HTTP Server log directory (available only when running as root, path /var/log/httpd is used in case of Fedora based image)
Notice: When mouting a directory from the host into the container, ensure that the mounted directory has the appropriate permissions and that the owner and group of the directory matches the user UID or name which is running inside the container.
Default SSL certificates are generated when Apache HTTP server container is started for the first time or own SSL certificates were not provided (see bolow how to provide them). SSL certificates are not stored in the base image but generated, so each container will have unique default SSL key pair. SSL certificate/key are stored in /etc/httpd/tls directory:
/etc/httpd/tls/localhost.key
/etc/httpd/tls/localhost.crt
In order to provide own SSL certificates for securing the connection with SSL, use the extending feature described above. In particular, put the SSL certificates into a separate directory inside your application:
./httpd-ssl/certs/server-cert-selfsigned.pem
./httpd-ssl/private/server-key.pem
The default behaviour is to look for the certificate and the private key in subdirectories certs/ and private/; those files will be used for the ssl settings in the httpd.
By default, Apache HTTP Server container runs as UID 1001. That means the volume mounted directories for the files (if mounted using -v option) need to be prepared properly, so the UID 1001 can read them.
To run the container as a different UID, use -u option. For example if you want to run the container as UID 1234, execute the following command:
podman run -d -u 1234 ubi9/httpd-24
To log into a volume mounted directory, the container needs to be run as UID 0 (see above).
The httpd deamon in the container logs to the standard output by default, so the log is available in the container log. The log can be examined by running:
podman logs <container>
Dockerfile and other sources for this container image are available on https://github.com/sclorg/httpd-container. In that repository, the Dockerfile for CentOS is called Dockerfile, the Dockerfile for RHEL7 is called Dockerfile.rhel7, the Dockerfile for RHEL8 is called Dockerfile.rhel8, and the Dockerfile for Fedora is called Dockerfile.fedora.
","long_description_markdown":"Apache HTTP Server 2.4 available as container, is a powerful, efficient,\nand extensible web server. Apache supports a variety of features, many implemented as compiled modules\nwhich extend the core functionality.\nThese can range from server-side programming language support to authentication schemes.\nVirtual hosting allows one Apache installation to serve many different Web sites.\"\n\n\nUsage in OpenShift\n---------------------\nIn this example, we assume that you are using the `ubi9/httpd-24` image, available through the `httpd:24` imagestream tag in Openshift.\nTo build a simple [httpd-sample-app](https://github.com/sclorg/httpd-ex.git) application in Openshift:\n\n```\noc new-app httpd:24~https://github.com/sclorg/httpd-ex.git\n```\n\nTo access the application:\n```\n$ oc get pods\n$ oc execThe Universal Base Image is designed and engineered to be the base layer for all of your containerized applications, middleware and utilities. This base image is freely redistributable, but Red Hat only supports Red Hat technologies through subscriptions for Red Hat products. This image is maintained by Red Hat and updated regularly.
","long_description_markdown":"The Universal Base Image is designed and engineered to be the base layer for all of your containerized applications, middleware and utilities. This base image is freely redistributable, but Red Hat only supports Red Hat technologies through subscriptions for Red Hat products. This image is maintained by Red Hat and updated regularly.","name":"Red Hat Universal Base Image 9","openshift_tags":"base , ubi, ubi9, universal base image","short_description":"Provides the latest release of Red Hat Universal Base Image 9."},"documentation_links":[{"title":"Understanding the UBI standard images","type":"Documentation","url":"https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html-single/building_running_and_managing_containers/index#con_understanding-the-ubi-standard-images_assembly_types-of-container-images"}],"fbc_opt_in":false,"freshness_grades_unknown_until_date":null,"includes_multiple_content_streams":false,"last_update_date":"2025-05-13T05:31:57.727000+00:00","metadata_source":"quay","namespace":"ubi9","non_production_only":false,"object_type":"containerRepository","privileged_images_allowed":false,"product_listings":["609560d9e2b160d361d24f98"],"protected_for_pull":false,"protected_for_search":false,"published":true,"registry":"registry.access.redhat.com","registry_target":"redhat-prod","release_categories":["Generally Available"],"repository":"ubi9/ubi","requires_terms":false,"source_container_image_enabled":true,"total_size_bytes":13599744787,"total_uncompressed_size_bytes":39954253797,"use_latest":true,"vendor_label":"redhat","_links":{"certification_project":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/ubi/projects/certification"},"images":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/ubi/images"},"operator_bundles":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/ubi/operators/bundles"},"product_listings":{"href":"/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/ubi/product-listings"},"vendor":{"href":"/v1/vendors/label/redhat"}}} +-- catalog.redhat.com/api/containers/v1/repositories/registry/registry.access.redhat.com/repository/ubi9/ubi/images -- +{"data":[{"_id":"6270e0fa80cc9b3025076e74","architecture":"s390x","creation_date":"2022-05-03T07:59:54.087000+00:00","image_id":"sha256:f14f9eb6c5ec6ea9664b54ea8816462e11abc096954d59eac536b64873d908f2","last_update_date":"2024-03-28T09:48:19.570000+00:00","object_type":"containerImage","parsed_data":{"architecture":"s390x","created":"2022-05-03T07:55:17.694008Z","layers":["sha256:d3d34aa2f6e9adb72bb1c5906cb4ed3aff28371252a2af8f2499152ac74232bb","sha256:6505b024e539929a1909c8820535221fe70806ce5467b5f30aef8d45a4a97da7"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:f04d9c84fb0c4d8e9b1398213ce546466aa5936f63091d1c839b14f589419f80","size_bytes":4641},{"layer_id":"sha256:38acd6d6a1423c6c8a752db3e80c97d314e519c7ff1c9d73f11c71bc0e157143","size_bytes":205816910}]},"_links":{"artifacts":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74/artifacts"},"requests":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74/requests"},"rpm_manifest":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74/rpm-manifest"},"test_results":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74/test-results"},"vulnerabilities":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74/vulnerabilities"}}},{"_id":"6270e0fc80cc9b3025076e80","architecture":"amd64","creation_date":"2022-05-03T07:59:56.806000+00:00","image_id":"sha256:88ad8a4433d3e9d8b5f247abc1396111148cbdfa0bee24542ad5d0e358a8f53b","last_update_date":"2024-03-28T09:47:44.512000+00:00","object_type":"containerImage","parsed_data":{"architecture":"amd64","created":"2022-05-03T07:55:12.352121Z","layers":["sha256:f95ee31bf3b71858108a30a93d9ffae722557f909d4b18e22f3157f96ca30dba","sha256:2c9b1d3d1a0af969583918cf19368bb46fe5d6c168c1af32e3b8be2ab2d57a88"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:0fbfc9ee0d4708c4609b66dc462ba478b0600fd7f0d3a687ddcefd0f298727cc","size_bytes":4642},{"layer_id":"sha256:a8504f08c55488bbc45f419b81bf06e23947df23e7defb73e47c94184024ad07","size_bytes":211055872}]},"_links":{"artifacts":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80/artifacts"},"requests":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80/requests"},"rpm_manifest":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80/rpm-manifest"},"test_results":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80/test-results"},"vulnerabilities":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80/vulnerabilities"}}},{"_id":"6270e0ff80cc9b3025076e8c","architecture":"ppc64le","creation_date":"2022-05-03T07:59:59.300000+00:00","image_id":"sha256:a107ef985c207ae3f4b12b93fad2eab4ca5f6611e3179104726c88586f38b31f","last_update_date":"2024-03-28T09:46:36.340000+00:00","object_type":"containerImage","parsed_data":{"architecture":"ppc64le","created":"2022-05-03T08:00:46.81832Z","layers":["sha256:8623dda09cc0ef358d183d3b2313455fea30b0d45f9493879f5e3a3f3b76efdf","sha256:c049534b9160c81cff9e87c9ba943324d258666c71d9a99374dafcefd5661e11"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:74534a300c1741d16489fc1abafce15b3451aae0a33ea07cb1b150cae5dface2","size_bytes":4647},{"layer_id":"sha256:38053c80ce88753bf1cd28ff5eda265d635b40c38a0a07d2ce2a2eebd6ebfd54","size_bytes":251360562}]},"_links":{"artifacts":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c/artifacts"},"requests":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c/requests"},"rpm_manifest":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c/rpm-manifest"},"test_results":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c/test-results"},"vulnerabilities":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c/vulnerabilities"}}},{"_id":"6270e10180cc9b3025076e97","architecture":"arm64","creation_date":"2022-05-03T08:00:01.739000+00:00","image_id":"sha256:bdf17ccf141aa51259ec63cc9fa8e01bcb74dcf8ed68c90c1e89f4d1fac30eba","last_update_date":"2024-03-28T09:48:17.933000+00:00","object_type":"containerImage","parsed_data":{"architecture":"arm64","created":"2022-05-03T07:56:38.395882Z","layers":["sha256:21f54a7cff457e5e27d7777aed5db47dd10426bd5a1bcbe2f0894383295f8a5d","sha256:b9680453047ed1c7559e26e0ba71504d2c7f71e622272257bc619ca5a5736c14"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:8cd39331f19aca0df47e3b9b76f17b0c80a268a2b7f28a43d54090df8a7e930a","size_bytes":4640},{"layer_id":"sha256:98a46c9e4bcca41e0d24440fff35333989df77139be129e89a0ed540029c248d","size_bytes":226640754}]},"_links":{"artifacts":{"href":"/v1/images/id/6270e10180cc9b3025076e97/artifacts"},"requests":{"href":"/v1/images/id/6270e10180cc9b3025076e97/requests"},"rpm_manifest":{"href":"/v1/images/id/6270e10180cc9b3025076e97/rpm-manifest"},"test_results":{"href":"/v1/images/id/6270e10180cc9b3025076e97/test-results"},"vulnerabilities":{"href":"/v1/images/id/6270e10180cc9b3025076e97/vulnerabilities"}}},{"_id":"62a83b424841f1737eea0706","architecture":"s390x","creation_date":"2022-06-14T07:39:46.888000+00:00","image_id":"sha256:038a6ef5cedbec707840dffd8d8cf761985c91a47777776032b83632e6fa9743","last_update_date":"2024-03-28T09:47:49.604000+00:00","object_type":"containerImage","parsed_data":{"architecture":"s390x","created":"2022-06-14T07:23:19.486601Z","layers":["sha256:981838a95888b5b858ea711a5d1cb5ee9f50e98152e1108ebb29e3599fc0574d","sha256:00226d577153da7fcc088ecb9f37b17254d131672aec65e211337e270118b601"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:ecf6eb0c14712d5a1ff0f293c29438f372fa74f5881f019dc269cc20fc4a908f","size_bytes":4685},{"layer_id":"sha256:b164e62e20b18e59481b559671093bfae2b7b6c5ea54afc388fb5670c9340f65","size_bytes":205867738}]},"_links":{"artifacts":{"href":"/v1/images/id/62a83b424841f1737eea0706/artifacts"},"requests":{"href":"/v1/images/id/62a83b424841f1737eea0706/requests"},"rpm_manifest":{"href":"/v1/images/id/62a83b424841f1737eea0706/rpm-manifest"},"test_results":{"href":"/v1/images/id/62a83b424841f1737eea0706/test-results"},"vulnerabilities":{"href":"/v1/images/id/62a83b424841f1737eea0706/vulnerabilities"}}},{"_id":"62a83b454841f1737eea070a","architecture":"ppc64le","creation_date":"2022-06-14T07:39:49.399000+00:00","image_id":"sha256:776199a3265426e28a9113792d1d7ea4468cb780671f193152284fa1f963d547","last_update_date":"2024-03-28T09:48:52.586000+00:00","object_type":"containerImage","parsed_data":{"architecture":"ppc64le","created":"2022-06-14T07:24:04.867191Z","layers":["sha256:b84257d6b7180364375d5480b557eee137833f0c4c14da82d4ed2b66e585eafe","sha256:78b7f2ed3f9b128feeb1ecc1aae4e26525d8b3bd8c117e4879150871c3c409c0"],"os":"linux","uncompressed_layer_sizes":[{"layer_id":"sha256:38b6836034afe6b024467b8c1b534e90bfc6bbb246bdaba0e19997d07b509a88","size_bytes":4691},{"layer_id":"sha256:3eb00e024c92f349d4ab20245a68167146fd35ea8fe4a0dca8255ed2dbaa907f","size_bytes":251426287}]},"_links":{"artifacts":{"href":"/v1/images/id/62a83b454841f1737eea070a/artifacts"},"requests":{"href":"/v1/images/id/62a83b454841f1737eea070a/requests"},"rpm_manifest":{"href":"/v1/images/id/62a83b454841f1737eea070a/rpm-manifest"},"test_results":{"href":"/v1/images/id/62a83b454841f1737eea070a/test-results"},"vulnerabilities":{"href":"/v1/images/id/62a83b454841f1737eea070a/vulnerabilities"}}}],"page":0,"page_size":6,"total":240} +-- catalog.redhat.com/api/containers/v1/images/id/6270e0fa80cc9b3025076e74/rpm-manifest -- +{"_id":"6270e0fb80cc9b3025076e7a","creation_date":"2022-05-03T07:59:55.812000+00:00","image_id":"6270e0fa80cc9b3025076e74","last_update_date":"2023-06-04T00:33:46.165000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-11.2.1-9.4.el9.s390x","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC version 11 shared support library","version":"11.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"System-wide crypto policies","version":"20220223"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2022a-1.el9_0.noarch","release":"1.el9_0","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2022a-1.el9_0.src","summary":"Timezone data","version":"2022a"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.29.26-3.el9_0.s390x","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-9.0-2.17.el9.s390x","release":"2.17.el9","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:9.0-2.17.el9.src","summary":"Red Hat Enterprise Linux release file","version":"9.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.13.7-6.el9.noarch","release":"6.el9","srpm_name":"setup","srpm_nevra":"setup-0:2.13.7-6.el9.src","summary":"A set of system configuration and setup files","version":"2.13.7"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.16-2.el9.s390x","release":"2.el9","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.16-2.el9.src","summary":"The basic directory layout for a Linux system","version":"3.16"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-13.el9.noarch","release":"13.el9","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-13.el9.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools-wheel","nvra":"python3-setuptools-wheel-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"The setuptools wheel","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pcre2-syntax","nvra":"pcre2-syntax-10.37-3.el9.1.noarch","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Documentation for PCRE2 regular expressions","version":"10.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.2-8.20210508.el9.noarch","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Descriptions of common terminals","version":"6.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.34-28.el9_0.s390x","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Minimal language packs for glibc.","version":"2.34"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.34-28.el9_0.s390x","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Common binaries and locale data for glibc","version":"2.34"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.34-28.el9_0.s390x","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"The GNU libc libraries","version":"2.34"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.2-8.20210508.el9.s390x","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Ncurses libraries","version":"6.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-5.1.8-4.el9.s390x","release":"4.el9","srpm_name":"bash","srpm_nevra":"bash-0:5.1.8-4.el9.src","summary":"The GNU Bourne Again shell","version":"5.1.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-31.el9_0.1.s390x","release":"31.el9_0.1","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-31.el9_0.1.src","summary":"Compression and decompression library","version":"1.2.11"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.5-7.el9.s390x","release":"7.el9","srpm_name":"xz","srpm_nevra":"xz-0:5.2.5-7.el9.src","summary":"Libraries for decoding LZMA compression","version":"5.2.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.8-8.el9.s390x","release":"8.el9","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.8-8.el9.src","summary":"Libraries for applications using bzip2","version":"1.0.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libzstd","nvra":"libzstd-1.5.1-2.el9.s390x","release":"2.el9","srpm_name":"zstd","srpm_nevra":"zstd-0:1.5.1-2.el9.src","summary":"Zstd shared library","version":"1.5.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.4.18-3.el9.s390x","release":"3.el9","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.4.18-3.el9.src","summary":"Extended crypt library for descrypt, md5crypt, bcrypt, and others","version":"4.4.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.48-8.el9.s390x","release":"8.el9","srpm_name":"libcap","srpm_nevra":"libcap-0:2.48-8.el9.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.48"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.34.1-5.el9.s390x","release":"5.el9","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.34.1-5.el9.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.34.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Universally unique ID library","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.18-8.el9.s390x","release":"8.el9","srpm_name":"popt","srpm_nevra":"popt-0:1.18-8.el9.src","summary":"C library for parsing command line parameters","version":"1.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.4.2-7.el9.s390x","release":"7.el9","srpm_name":"libffi","srpm_nevra":"libffi-0:3.4.2-7.el9.src","summary":"A portable foreign function interface library","version":"3.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.24.1-2.el9.s390x","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.24.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.42-5.el9.s390x","release":"5.el9","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.42-5.el9.src","summary":"Library for error values used by GnuPG components","version":"1.42"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.13-1.el9.s390x","release":"1.el9","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.13-1.el9.src","summary":"Library providing XML and HTML support","version":"2.9.13"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-8.1-4.el9.s390x","release":"4.el9","srpm_name":"readline","srpm_nevra":"readline-0:8.1-4.el9.src","summary":"A library for editing typed command lines","version":"8.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.2.0-10.el9.s390x","release":"10.el9","srpm_name":"gmp","srpm_nevra":"gmp-1:6.2.0-10.el9.src","summary":"A GNU arbitrary precision library","version":"6.2.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.14-11.el9.s390x","release":"11.el9","srpm_name":"json-c","srpm_nevra":"json-c-0:0.14-11.el9.src","summary":"JSON implementation in C","version":"0.14"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Formatting library for ls-like programs.","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-11.2.1-9.4.el9.s390x","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GNU Standard C++ Library","version":"11.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.4.2-4.el9.s390x","release":"4.el9","srpm_name":"lua","srpm_nevra":"lua-0:5.4.2-4.el9.src","summary":"Libraries for lua","version":"5.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.10.0-2.el9.s390x","release":"2.el9","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.10.0-2.el9.src","summary":"A general-purpose cryptography library","version":"1.10.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.186-1.el9.s390x","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Library to read and write ELF files","version":"0.186"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.39-8.el9.s390x","release":"8.el9","srpm_name":"file","srpm_nevra":"file-0:5.39-8.el9.src","summary":"Libraries for applications using libmagic","version":"5.39"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.10-12.el9_0.s390x","release":"12.el9_0","srpm_name":"expat","srpm_nevra":"expat-0:2.2.10-12.el9_0.src","summary":"An XML parser library","version":"2.2.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.5.1-3.el9.s390x","release":"3.el9","srpm_name":"attr","srpm_nevra":"attr-0:2.5.1-3.el9.src","summary":"Dynamic library for extended attribute support","version":"2.5.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.3.1-3.el9.s390x","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Dynamic library for access control list support","version":"2.3.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.8.2-7.el9.s390x","release":"7.el9","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.8.2-7.el9.src","summary":"Alternate posix capabilities library","version":"0.8.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0.7-101.el9_0.2.s390x","release":"101.el9_0.2","srpm_name":"audit","srpm_nevra":"audit-0:3.0.7-101.el9_0.2.src","summary":"Dynamic library for libaudit","version":"3.0.7"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.46.5-2.el9.s390x","release":"2.el9","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.46.5-2.el9.src","summary":"Common error description library","version":"1.46.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.9.3-5.el9.s390x","release":"5.el9","srpm_name":"lz4","srpm_nevra":"lz4-0:1.9.3-5.el9.src","summary":"Libaries for lz4","version":"1.9.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.5-3.el9.s390x","release":"3.el9","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.5-3.el9.src","summary":"GnuPG IPC library","version":"2.5.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.19-4.el9.s390x","release":"4.el9","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.19-4.el9.src","summary":"Libraries files for gdbm","version":"1.19"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.6.1-4.el9.s390x","release":"4.el9","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.6.1-4.el9.src","summary":"Key utilities library","version":"1.6.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-3.3-2.el9.s390x","release":"2.el9","srpm_name":"libsepol","srpm_nevra":"libsepol-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.13-4.el9.s390x","release":"4.el9","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.13-4.el9.src","summary":"Library for handling page faults in user mode","version":"2.13"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.16.0-7.el9.s390x","release":"7.el9","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.16.0-7.el9.src","summary":"The ASN.1 library used in GNUTLS","version":"4.16.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.10-15.el9.s390x","release":"15.el9","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.10-15.el9.src","summary":"GNU Unicode string library","version":"0.9.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.44-3.el9.3.s390x","release":"3.el9.3","srpm_name":"pcre","srpm_nevra":"pcre-0:8.44-3.el9.3.src","summary":"Perl-compatible regular expression library","version":"8.44"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.6-5.el9.s390x","release":"5.el9","srpm_name":"grep","srpm_nevra":"grep-0:3.6-5.el9.src","summary":"Pattern matching utilities","version":"3.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.37-3.el9.1.s390x","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Perl-compatible regular expression library","version":"10.37"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-3.3-2.el9.s390x","release":"2.el9","srpm_name":"libselinux","srpm_nevra":"libselinux-0:3.3-2.el9.src","summary":"SELinux library and simple utilities","version":"3.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.32-31.el9.s390x","release":"31.el9","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.32-31.el9.src","summary":"coreutils multicall binary","version":"8.32"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Block device ID library","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Device mounting library","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.8-9.el9.s390x","release":"9.el9","srpm_name":"sed","srpm_nevra":"sed-0:4.8-9.el9.src","summary":"A GNU stream text editor","version":"4.8"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Partitioning library for fdisk-like programs.","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.10-9.el9_0.s390x","release":"9.el9_0","srpm_name":"gzip","srpm_nevra":"gzip-0:1.10-9.el9_0.src","version":"1.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-27.el9.s390x","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cracklib-dicts","nvra":"cracklib-dicts-2.9.6-27.el9.s390x","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"The standard CrackLib dictionaries","version":"2.9.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-3.3-2.el9.s390x","release":"2.el9","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.9-3.el9.s390x","release":"3.el9","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.9-3.el9.src","summary":"Utilities for managing accounts and shadow password files","version":"4.9"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.2.1-6.el9.s390x","release":"6.el9","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.2.1-6.el9.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.3.0-7.el9.s390x","release":"7.el9","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.3.0-7.el9.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.3.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.3.1-3.el9.s390x","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Access control list utilities","version":"2.3.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.18-1.el9.s390x","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Comps XML file manipulation library","version":"0.1.18"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-4.1.0-7.el9.s390x","release":"7.el9","srpm_name":"mpfr","srpm_nevra":"mpfr-0:4.1.0-7.el9.src","summary":"C library for multiple-precision floating-point computations","version":"4.1.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-5.1.0-6.el9.s390x","release":"6.el9","srpm_name":"gawk","srpm_nevra":"gawk-0:5.1.0-6.el9.src","summary":"The GNU version of the AWK text processing utility","version":"5.1.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.7.3-2.el9.s390x","release":"2.el9","srpm_name":"nettle","srpm_nevra":"nettle-0:3.7.3-2.el9.src","summary":"A low-level cryptographic library","version":"3.7.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.5.1-4.el9.s390x","release":"4.el9","srpm_name":"libksba","srpm_nevra":"libksba-0:1.5.1-4.el9.src","summary":"CMS and X.509 library","version":"1.5.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"systemd-rpm-macros","nvra":"systemd-rpm-macros-250-6.el9_0.noarch","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"Macros that define paths and scriptlets related to systemd","version":"250"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"alternatives","nvra":"alternatives-1.20-2.el9.s390x","release":"2.el9","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.20-2.el9.src","summary":"A tool to maintain symbolic links determining default commands","version":"1.20"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.24.1-2.el9.s390x","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"System trust module from p11-kit","version":"0.24.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2020.2.50-94.el9.noarch","release":"94.el9","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2020.2.50-94.el9.src","summary":"The Mozilla CA root certificate bundle","version":"2020.2.50"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-3.0.1-23.el9_0.s390x","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"A general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-250-6.el9_0.s390x","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd libraries","version":"250"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.7.3-9.el9.s390x","release":"9.el9","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.7.3-9.el9.src","summary":"A TLS protocol implementation","version":"3.7.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.68.4-5.el9.s390x","release":"5.el9","srpm_name":"glib2","srpm_nevra":"glib2-0:2.68.4-5.el9.src","summary":"A library of handy utility functions","version":"2.68.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.68.0-10.el9.s390x","release":"10.el9","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.68.0-10.el9.src","summary":"Introspection system for GObject-based libraries","version":"1.68.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.6.6-1.el9.s390x","release":"1.el9","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.6.6-1.el9.src","summary":"Library for JavaScript Object Notation format","version":"1.6.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-7.el9.s390x","release":"7.el9","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-7.el9.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.20-5.el9.s390x","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"Libraries for accessing D-BUS","version":"1.12.20"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"util-linux-core","nvra":"util-linux-core-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"The most essential utilities from the util-linux suite.","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-28-7.el9.s390x","release":"7.el9","srpm_name":"kmod","srpm_nevra":"kmod-0:28-7.el9.src","summary":"Libraries to handle kernel module loading and unloading","version":"28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.5.3-1.el9.s390x","release":"1.el9","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.5.3-1.el9.src","summary":"A library for handling streaming archive formats","version":"3.5.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"openssl","nvra":"openssl-3.0.1-23.el9_0.s390x","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"Utilities from the general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pip-wheel","nvra":"python3-pip-wheel-21.2.3-6.el9.noarch","release":"6.el9","srpm_name":"python-pip","srpm_nevra":"python-pip-0:21.2.3-6.el9.src","summary":"The pip wheel","version":"21.2.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3","nvra":"python3-3.9.10-2.el9.s390x","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python 3.9 interpreter","version":"3.9.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.9.10-2.el9.s390x","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python runtime libraries","version":"3.9.10"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.18-2.el9.s390x","release":"2.el9","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.18-2.el9.src","summary":"D-Bus bindings for python3","version":"1.2.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.15.0-9.el9.noarch","release":"9.el9","srpm_name":"python-six","srpm_nevra":"python-six-0:1.15.0-9.el9.src","summary":"Python 2 and 3 compatibility utilities","version":"1.15.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.8.1-6.el9.noarch","release":"6.el9","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.8.1-6.el9.src","summary":"Powerful extensions to the standard datetime module","version":"2.8.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-45.el9.noarch","release":"45.el9","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-45.el9.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-idna","nvra":"python3-idna-2.10-7.el9.noarch","release":"7.el9","srpm_name":"python-idna","srpm_nevra":"python-idna-0:2.10-7.el9.src","summary":"Internationalized Domain Names in Applications (IDNA)","version":"2.10"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools","nvra":"python3-setuptools-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"Easily build and distribute Python 3 packages","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-25.el9.noarch","release":"25.el9","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-25.el9.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.18-1.el9.s390x","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Python 3 bindings for libcomps library","version":"0.1.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-chardet","nvra":"python3-chardet-4.0.0-5.el9.noarch","release":"5.el9","srpm_name":"python-chardet","srpm_nevra":"python-chardet-0:4.0.0-5.el9.src","summary":"Character encoding auto-detection in Python","version":"4.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.4.2-6.el9.noarch","release":"6.el9","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.4.2-6.el9.src","summary":"Module to simplify usage of decorators in python3","version":"4.4.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.40.1-5.el9.s390x","release":"5.el9","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.40.1-5.el9.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.40.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pysocks","nvra":"python3-pysocks-1.7.1-12.el9.noarch","release":"12.el9","srpm_name":"python-pysocks","srpm_nevra":"python-pysocks-0:1.7.1-12.el9.src","summary":"A Python SOCKS client module","version":"1.7.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-urllib3","nvra":"python3-urllib3-1.26.5-3.el9.noarch","release":"3.el9","srpm_name":"python-urllib3","srpm_nevra":"python-urllib3-0:1.26.5-3.el9.src","summary":"Python3 HTTP library with thread-safe connection pooling and file post","version":"1.26.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-requests","nvra":"python3-requests-2.25.1-6.el9.noarch","release":"6.el9","srpm_name":"python-requests","srpm_nevra":"python-requests-0:2.25.1-6.el9.src","summary":"HTTP library, written in Python, for human beings","version":"2.25.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-cloud-what","nvra":"python3-cloud-what-1.29.26-3.el9_0.s390x","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Python package for detection of public cloud provider","version":"1.29.26"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-53.el9.s390x","release":"53.el9","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-53.el9.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libeconf","nvra":"libeconf-0.4.1-2.el9.s390x","release":"2.el9","srpm_name":"libeconf","srpm_nevra":"libeconf-0:0.4.1-2.el9.src","summary":"Enhanced config file parser library","version":"0.4.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.4-8.el9.s390x","release":"8.el9","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.4-8.el9.src","summary":"A library for password generation and password quality checking","version":"1.4.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.5.1-9.el9.s390x","release":"9.el9","srpm_name":"pam","srpm_nevra":"pam-0:1.5.1-9.el9.src","summary":"An extensible library which provides authentication for applications","version":"1.5.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.37.4-3.el9.s390x","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"A collection of basic system utilities","version":"2.37.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libgomp","nvra":"libgomp-11.2.1-9.4.el9.s390x","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC OpenMP v4.5 shared support library","version":"11.2.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.43.0-5.el9.s390x","release":"5.el9","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.43.0-5.el9.src","summary":"A library implementing the HTTP/2 protocol","version":"1.43.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.5.0-10.el9.s390x","release":"10.el9","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.5.0-10.el9.src","summary":"Convenience library for kernel netlink sockets","version":"3.5.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.15-2.el9.s390x","release":"2.el9","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.15-2.el9.src","summary":"Python module to interface with ethtool","version":"0.15"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.5.2-2.el9.s390x","release":"2.el9","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.5.2-2.el9.src","summary":"Enhanced seccomp library","version":"2.5.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.183-4.el9.s390x","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device mapper utility","version":"1.02.183"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.183-4.el9.s390x","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device-mapper shared library","version":"1.02.183"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.4.3-4.el9.s390x","release":"4.el9","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.4.3-4.el9.src","summary":"Cryptsetup shared library","version":"2.4.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.20-5.el9.s390x","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus","version":"1.12.20"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-250-6.el9_0.s390x","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd PAM module","version":"250"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-250-6.el9_0.s390x","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"System and Service Manager","version":"250"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.20-5.el9.noarch","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus configuration","version":"1.12.20"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"dbus-broker","nvra":"dbus-broker-28-5.el9.s390x","release":"5.el9","srpm_name":"dbus-broker","srpm_nevra":"dbus-broker-0:28-5.el9.src","summary":"Linux D-Bus Message Broker","version":"28"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.186-1.el9.noarch","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Default yama attach scope sysctl setting","version":"0.186"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.186-1.el9.s390x","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Libraries to handle compiled objects","version":"0.186"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.2-3.el9.s390x","release":"3.el9","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.2-3.el9.src","summary":"Main loop abstraction library","version":"0.3.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.19.1-15.el9_0.s390x","release":"15.el9_0","srpm_name":"krb5","srpm_nevra":"krb5-0:1.19.1-15.el9_0.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.19.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libcurl-minimal","nvra":"libcurl-minimal-7.76.1-14.el9.s390x","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of libcurl for minimal installations","version":"7.76.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"curl-minimal","nvra":"curl-minimal-7.76.1-14.el9.s390x","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of curl for minimal installations","version":"7.76.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.16.1.3-12.el9_0.s390x","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"The RPM package management system","version":"4.16.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.16.1.3-12.el9_0.s390x","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for manipulating RPM packages","version":"4.16.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.7.20-2.el9.s390x","release":"2.el9","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.7.20-2.el9.src","summary":"Package dependency solver","version":"0.7.20"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.16.1.3-12.el9_0.s390x","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for building RPM packages","version":"4.16.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"tpm2-tss","nvra":"tpm2-tss-3.0.3-7.el9.s390x","release":"7.el9","srpm_name":"tpm2-tss","srpm_nevra":"tpm2-tss-0:3.0.3-7.el9.src","summary":"TPM2.0 Software Stack","version":"3.0.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.4-4.el9.s390x","release":"4.el9","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.4-4.el9.src","summary":"IMA/EVM support utilities","version":"1.4"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-20.el9.s390x","release":"20.el9","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-20.el9.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.59-4.el9_0.s390x","release":"4.el9_0","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.59-4.el9_0.src","summary":"LDAP support libraries","version":"2.4.59"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.63-10.el9.s390x","release":"10.el9","srpm_name":"libuser","srpm_nevra":"libuser-0:0.63-10.el9.src","summary":"A user and group account administration library","version":"0.63"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-12.el9.s390x","release":"12.el9","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-12.el9.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.114-4.el9.s390x","release":"4.el9","srpm_name":"usermode","srpm_nevra":"usermode-0:1.114-4.el9.src","summary":"Tools for certain user account management tasks","version":"1.114"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.2.5-7.el9.s390x","release":"7.el9","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.2.5-7.el9.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.2.5"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libmodulemd","nvra":"libmodulemd-2.13.0-2.el9.s390x","release":"2.el9","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.13.0-2.el9.src","summary":"Module metadata manipulation library","version":"2.13.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.6-8.el9.s390x","release":"8.el9","srpm_name":"npth","srpm_nevra":"npth-0:1.6-8.el9.src","summary":"The New GNU Portable Threads library","version":"1.6"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.3.3-1.el9.s390x","release":"1.el9","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.3.3-1.el9.src","summary":"Utility for secure communication and data storage","version":"2.3.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.15.1-6.el9.s390x","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.15.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.14.2-1.el9.s390x","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Repodata downloading library","version":"1.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.65.0-5.el9_0.s390x","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.65.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.65.0-5.el9_0.s390x","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.65.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.65.0-5.el9_0.s390x","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.65.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.14.2-1.el9.s390x","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Python 3 bindings for the librepo library","version":"1.14.2"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.15.1-6.el9.s390x","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"gpgme bindings for Python 3","version":"1.15.1"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"rpm-sign-libs","nvra":"rpm-sign-libs-4.16.1.3-12.el9_0.s390x","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for signing RPM packages","version":"4.16.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.16.1.3-12.el9_0.s390x","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.16.1.3"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.29.26-3.el9_0.s390x","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-27.el9.s390x","release":"27.el9","srpm_name":"which","srpm_nevra":"which-0:2.21-27.el9.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.21-2.el9.2.s390x","release":"2.el9.2","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.21-2.el9.2.src","summary":"Detect if we are running in a virtual machine","version":"1.21"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.15.2-6.el9.noarch","release":"6.el9","srpm_name":"libreport","srpm_nevra":"libreport-0:2.15.2-6.el9.src","summary":"Filesystem layout for libreport","version":"2.15.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Common data and configuration files for DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Python 3 interface to DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"libdnf-plugin-subscription-manager","nvra":"libdnf-plugin-subscription-manager-1.29.26-3.el9_0.s390x","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Subscription Manager plugin for libdnf","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.24-4.el9_0.noarch","release":"4.el9_0","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.24-4.el9_0.src","summary":"Core Plugins for DNF","version":"4.0.24"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"fonts-filesystem","nvra":"fonts-filesystem-2.0.5-7.el9.1.noarch","release":"7.el9.1","srpm_name":"fonts-rpm-macros","srpm_nevra":"fonts-rpm-macros-1:2.0.5-7.el9.1.src","summary":"Directories used by font packages","version":"2.0.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dejavu-sans-fonts","nvra":"dejavu-sans-fonts-2.37-18.el9.noarch","release":"18.el9","srpm_name":"dejavu-fonts","srpm_nevra":"dejavu-fonts-0:2.37-18.el9.src","summary":"DejaVu Sans, a variable-width sans-serif font family","version":"2.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-font-en","nvra":"langpacks-core-font-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English core font meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-en","nvra":"langpacks-core-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks core meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks meta-package","version":"3.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.29.26-3.el9_0.s390x","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Tools and libraries for subscription and repository management","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies-scripts","nvra":"crypto-policies-scripts-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"Tool to switch between crypto policies","version":"20220223"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.8.0-5.el9.s390x","release":"5.el9","srpm_name":"findutils","srpm_nevra":"findutils-1:4.8.0-5.el9.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.8.0"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.34-3.el9.s390x","release":"3.el9","srpm_name":"tar","srpm_nevra":"tar-2:1.34-3.el9.src","summary":"GNU file archiving program","version":"1.34"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.2.2637-15.el9.s390x","release":"15.el9","srpm_name":"vim","srpm_nevra":"vim-2:8.2.2637-15.el9.src","summary":"A minimal version of the VIM editor","version":"8.2.2637"},{"architecture":"s390x","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-10.2-9.el9.s390x","release":"9.el9","srpm_name":"gdb","srpm_nevra":"gdb-0:10.2-9.el9.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"10.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"rootfiles","nvra":"rootfiles-8.1-31.el9.noarch","release":"31.el9","srpm_name":"rootfiles","srpm_nevra":"rootfiles-0:8.1-31.el9.src","summary":"The basic required files for the root user's directory","version":"8.1"}],"_links":{"image":{"href":"/v1/images/id/6270e0fa80cc9b3025076e74"}}} +-- catalog.redhat.com/api/containers/v1/images/id/6270e0fc80cc9b3025076e80/rpm-manifest -- +{"_id":"6270e0fe80cc9b3025076e86","creation_date":"2022-05-03T07:59:58.253000+00:00","image_id":"6270e0fc80cc9b3025076e80","last_update_date":"2023-06-04T00:33:45.691000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-11.2.1-9.4.el9.x86_64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC version 11 shared support library","version":"11.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"System-wide crypto policies","version":"20220223"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2022a-1.el9_0.noarch","release":"1.el9_0","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2022a-1.el9_0.src","summary":"Timezone data","version":"2022a"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.29.26-3.el9_0.x86_64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-9.0-2.17.el9.x86_64","release":"2.17.el9","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:9.0-2.17.el9.src","summary":"Red Hat Enterprise Linux release file","version":"9.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.13.7-6.el9.noarch","release":"6.el9","srpm_name":"setup","srpm_nevra":"setup-0:2.13.7-6.el9.src","summary":"A set of system configuration and setup files","version":"2.13.7"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.16-2.el9.x86_64","release":"2.el9","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.16-2.el9.src","summary":"The basic directory layout for a Linux system","version":"3.16"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-13.el9.noarch","release":"13.el9","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-13.el9.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools-wheel","nvra":"python3-setuptools-wheel-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"The setuptools wheel","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pcre2-syntax","nvra":"pcre2-syntax-10.37-3.el9.1.noarch","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Documentation for PCRE2 regular expressions","version":"10.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.2-8.20210508.el9.noarch","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Descriptions of common terminals","version":"6.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.34-28.el9_0.x86_64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Minimal language packs for glibc.","version":"2.34"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.34-28.el9_0.x86_64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Common binaries and locale data for glibc","version":"2.34"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.34-28.el9_0.x86_64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"The GNU libc libraries","version":"2.34"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.2-8.20210508.el9.x86_64","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Ncurses libraries","version":"6.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-5.1.8-4.el9.x86_64","release":"4.el9","srpm_name":"bash","srpm_nevra":"bash-0:5.1.8-4.el9.src","summary":"The GNU Bourne Again shell","version":"5.1.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-31.el9_0.1.x86_64","release":"31.el9_0.1","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-31.el9_0.1.src","summary":"Compression and decompression library","version":"1.2.11"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.5-7.el9.x86_64","release":"7.el9","srpm_name":"xz","srpm_nevra":"xz-0:5.2.5-7.el9.src","summary":"Libraries for decoding LZMA compression","version":"5.2.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.8-8.el9.x86_64","release":"8.el9","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.8-8.el9.src","summary":"Libraries for applications using bzip2","version":"1.0.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.4.18-3.el9.x86_64","release":"3.el9","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.4.18-3.el9.src","summary":"Extended crypt library for descrypt, md5crypt, bcrypt, and others","version":"4.4.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libzstd","nvra":"libzstd-1.5.1-2.el9.x86_64","release":"2.el9","srpm_name":"zstd","srpm_nevra":"zstd-0:1.5.1-2.el9.src","summary":"Zstd shared library","version":"1.5.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.48-8.el9.x86_64","release":"8.el9","srpm_name":"libcap","srpm_nevra":"libcap-0:2.48-8.el9.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.48"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.34.1-5.el9.x86_64","release":"5.el9","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.34.1-5.el9.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.34.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Universally unique ID library","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.18-8.el9.x86_64","release":"8.el9","srpm_name":"popt","srpm_nevra":"popt-0:1.18-8.el9.src","summary":"C library for parsing command line parameters","version":"1.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.13-1.el9.x86_64","release":"1.el9","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.13-1.el9.src","summary":"Library providing XML and HTML support","version":"2.9.13"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.4.2-7.el9.x86_64","release":"7.el9","srpm_name":"libffi","srpm_nevra":"libffi-0:3.4.2-7.el9.src","summary":"A portable foreign function interface library","version":"3.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.24.1-2.el9.x86_64","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.24.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.42-5.el9.x86_64","release":"5.el9","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.42-5.el9.src","summary":"Library for error values used by GnuPG components","version":"1.42"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-8.1-4.el9.x86_64","release":"4.el9","srpm_name":"readline","srpm_nevra":"readline-0:8.1-4.el9.src","summary":"A library for editing typed command lines","version":"8.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.2.0-10.el9.x86_64","release":"10.el9","srpm_name":"gmp","srpm_nevra":"gmp-1:6.2.0-10.el9.src","summary":"A GNU arbitrary precision library","version":"6.2.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.14-11.el9.x86_64","release":"11.el9","srpm_name":"json-c","srpm_nevra":"json-c-0:0.14-11.el9.src","summary":"JSON implementation in C","version":"0.14"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Formatting library for ls-like programs.","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-11.2.1-9.4.el9.x86_64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GNU Standard C++ Library","version":"11.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.4.2-4.el9.x86_64","release":"4.el9","srpm_name":"lua","srpm_nevra":"lua-0:5.4.2-4.el9.src","summary":"Libraries for lua","version":"5.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.10.0-2.el9.x86_64","release":"2.el9","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.10.0-2.el9.src","summary":"A general-purpose cryptography library","version":"1.10.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.186-1.el9.x86_64","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Library to read and write ELF files","version":"0.186"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.39-8.el9.x86_64","release":"8.el9","srpm_name":"file","srpm_nevra":"file-0:5.39-8.el9.src","summary":"Libraries for applications using libmagic","version":"5.39"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.10-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"expat","srpm_nevra":"expat-0:2.2.10-12.el9_0.src","summary":"An XML parser library","version":"2.2.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.5.1-3.el9.x86_64","release":"3.el9","srpm_name":"attr","srpm_nevra":"attr-0:2.5.1-3.el9.src","summary":"Dynamic library for extended attribute support","version":"2.5.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.3.1-3.el9.x86_64","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Dynamic library for access control list support","version":"2.3.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.8.2-7.el9.x86_64","release":"7.el9","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.8.2-7.el9.src","summary":"Alternate posix capabilities library","version":"0.8.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0.7-101.el9_0.2.x86_64","release":"101.el9_0.2","srpm_name":"audit","srpm_nevra":"audit-0:3.0.7-101.el9_0.2.src","summary":"Dynamic library for libaudit","version":"3.0.7"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.46.5-2.el9.x86_64","release":"2.el9","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.46.5-2.el9.src","summary":"Common error description library","version":"1.46.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.9.3-5.el9.x86_64","release":"5.el9","srpm_name":"lz4","srpm_nevra":"lz4-0:1.9.3-5.el9.src","summary":"Libaries for lz4","version":"1.9.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.5-3.el9.x86_64","release":"3.el9","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.5-3.el9.src","summary":"GnuPG IPC library","version":"2.5.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.19-4.el9.x86_64","release":"4.el9","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.19-4.el9.src","summary":"Libraries files for gdbm","version":"1.19"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.6.1-4.el9.x86_64","release":"4.el9","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.6.1-4.el9.src","summary":"Key utilities library","version":"1.6.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-3.3-2.el9.x86_64","release":"2.el9","srpm_name":"libsepol","srpm_nevra":"libsepol-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.13-4.el9.x86_64","release":"4.el9","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.13-4.el9.src","summary":"Library for handling page faults in user mode","version":"2.13"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.16.0-7.el9.x86_64","release":"7.el9","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.16.0-7.el9.src","summary":"The ASN.1 library used in GNUTLS","version":"4.16.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.10-15.el9.x86_64","release":"15.el9","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.10-15.el9.src","summary":"GNU Unicode string library","version":"0.9.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.44-3.el9.3.x86_64","release":"3.el9.3","srpm_name":"pcre","srpm_nevra":"pcre-0:8.44-3.el9.3.src","summary":"Perl-compatible regular expression library","version":"8.44"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.6-5.el9.x86_64","release":"5.el9","srpm_name":"grep","srpm_nevra":"grep-0:3.6-5.el9.src","summary":"Pattern matching utilities","version":"3.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.37-3.el9.1.x86_64","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Perl-compatible regular expression library","version":"10.37"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-3.3-2.el9.x86_64","release":"2.el9","srpm_name":"libselinux","srpm_nevra":"libselinux-0:3.3-2.el9.src","summary":"SELinux library and simple utilities","version":"3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.32-31.el9.x86_64","release":"31.el9","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.32-31.el9.src","summary":"coreutils multicall binary","version":"8.32"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Block device ID library","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Device mounting library","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.8-9.el9.x86_64","release":"9.el9","srpm_name":"sed","srpm_nevra":"sed-0:4.8-9.el9.src","summary":"A GNU stream text editor","version":"4.8"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Partitioning library for fdisk-like programs.","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.10-9.el9_0.x86_64","release":"9.el9_0","srpm_name":"gzip","srpm_nevra":"gzip-0:1.10-9.el9_0.src","version":"1.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-27.el9.x86_64","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cracklib-dicts","nvra":"cracklib-dicts-2.9.6-27.el9.x86_64","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"The standard CrackLib dictionaries","version":"2.9.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-3.3-2.el9.x86_64","release":"2.el9","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.9-3.el9.x86_64","release":"3.el9","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.9-3.el9.src","summary":"Utilities for managing accounts and shadow password files","version":"4.9"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.2.1-6.el9.x86_64","release":"6.el9","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.2.1-6.el9.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.3.0-7.el9.x86_64","release":"7.el9","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.3.0-7.el9.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.3.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.3.1-3.el9.x86_64","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Access control list utilities","version":"2.3.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.18-1.el9.x86_64","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Comps XML file manipulation library","version":"0.1.18"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-4.1.0-7.el9.x86_64","release":"7.el9","srpm_name":"mpfr","srpm_nevra":"mpfr-0:4.1.0-7.el9.src","summary":"C library for multiple-precision floating-point computations","version":"4.1.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-5.1.0-6.el9.x86_64","release":"6.el9","srpm_name":"gawk","srpm_nevra":"gawk-0:5.1.0-6.el9.src","summary":"The GNU version of the AWK text processing utility","version":"5.1.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.7.3-2.el9.x86_64","release":"2.el9","srpm_name":"nettle","srpm_nevra":"nettle-0:3.7.3-2.el9.src","summary":"A low-level cryptographic library","version":"3.7.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.5.1-4.el9.x86_64","release":"4.el9","srpm_name":"libksba","srpm_nevra":"libksba-0:1.5.1-4.el9.src","summary":"CMS and X.509 library","version":"1.5.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"systemd-rpm-macros","nvra":"systemd-rpm-macros-250-6.el9_0.noarch","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"Macros that define paths and scriptlets related to systemd","version":"250"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"alternatives","nvra":"alternatives-1.20-2.el9.x86_64","release":"2.el9","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.20-2.el9.src","summary":"A tool to maintain symbolic links determining default commands","version":"1.20"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.24.1-2.el9.x86_64","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"System trust module from p11-kit","version":"0.24.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2020.2.50-94.el9.noarch","release":"94.el9","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2020.2.50-94.el9.src","summary":"The Mozilla CA root certificate bundle","version":"2020.2.50"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-3.0.1-23.el9_0.x86_64","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"A general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-250-6.el9_0.x86_64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd libraries","version":"250"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.7.3-9.el9.x86_64","release":"9.el9","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.7.3-9.el9.src","summary":"A TLS protocol implementation","version":"3.7.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.68.4-5.el9.x86_64","release":"5.el9","srpm_name":"glib2","srpm_nevra":"glib2-0:2.68.4-5.el9.src","summary":"A library of handy utility functions","version":"2.68.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.68.0-10.el9.x86_64","release":"10.el9","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.68.0-10.el9.src","summary":"Introspection system for GObject-based libraries","version":"1.68.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.6.6-1.el9.x86_64","release":"1.el9","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.6.6-1.el9.src","summary":"Library for JavaScript Object Notation format","version":"1.6.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-7.el9.x86_64","release":"7.el9","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-7.el9.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.20-5.el9.x86_64","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"Libraries for accessing D-BUS","version":"1.12.20"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"util-linux-core","nvra":"util-linux-core-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"The most essential utilities from the util-linux suite.","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-28-7.el9.x86_64","release":"7.el9","srpm_name":"kmod","srpm_nevra":"kmod-0:28-7.el9.src","summary":"Libraries to handle kernel module loading and unloading","version":"28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.5.3-1.el9.x86_64","release":"1.el9","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.5.3-1.el9.src","summary":"A library for handling streaming archive formats","version":"3.5.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"openssl","nvra":"openssl-3.0.1-23.el9_0.x86_64","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"Utilities from the general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pip-wheel","nvra":"python3-pip-wheel-21.2.3-6.el9.noarch","release":"6.el9","srpm_name":"python-pip","srpm_nevra":"python-pip-0:21.2.3-6.el9.src","summary":"The pip wheel","version":"21.2.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3","nvra":"python3-3.9.10-2.el9.x86_64","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python 3.9 interpreter","version":"3.9.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.9.10-2.el9.x86_64","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python runtime libraries","version":"3.9.10"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.18-2.el9.x86_64","release":"2.el9","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.18-2.el9.src","summary":"D-Bus bindings for python3","version":"1.2.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.15.0-9.el9.noarch","release":"9.el9","srpm_name":"python-six","srpm_nevra":"python-six-0:1.15.0-9.el9.src","summary":"Python 2 and 3 compatibility utilities","version":"1.15.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.8.1-6.el9.noarch","release":"6.el9","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.8.1-6.el9.src","summary":"Powerful extensions to the standard datetime module","version":"2.8.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-45.el9.noarch","release":"45.el9","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-45.el9.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-idna","nvra":"python3-idna-2.10-7.el9.noarch","release":"7.el9","srpm_name":"python-idna","srpm_nevra":"python-idna-0:2.10-7.el9.src","summary":"Internationalized Domain Names in Applications (IDNA)","version":"2.10"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools","nvra":"python3-setuptools-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"Easily build and distribute Python 3 packages","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-25.el9.noarch","release":"25.el9","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-25.el9.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.18-1.el9.x86_64","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Python 3 bindings for libcomps library","version":"0.1.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-chardet","nvra":"python3-chardet-4.0.0-5.el9.noarch","release":"5.el9","srpm_name":"python-chardet","srpm_nevra":"python-chardet-0:4.0.0-5.el9.src","summary":"Character encoding auto-detection in Python","version":"4.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.4.2-6.el9.noarch","release":"6.el9","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.4.2-6.el9.src","summary":"Module to simplify usage of decorators in python3","version":"4.4.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.40.1-5.el9.x86_64","release":"5.el9","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.40.1-5.el9.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.40.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libxml2","nvra":"python3-libxml2-2.9.13-1.el9.x86_64","release":"1.el9","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.13-1.el9.src","summary":"Python 3 bindings for the libxml2 library","version":"2.9.13"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-dmidecode","nvra":"python3-dmidecode-3.12.2-27.el9.x86_64","release":"27.el9","srpm_name":"python-dmidecode","srpm_nevra":"python-dmidecode-0:3.12.2-27.el9.src","summary":"Python 3 module to access DMI data","version":"3.12.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pysocks","nvra":"python3-pysocks-1.7.1-12.el9.noarch","release":"12.el9","srpm_name":"python-pysocks","srpm_nevra":"python-pysocks-0:1.7.1-12.el9.src","summary":"A Python SOCKS client module","version":"1.7.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-urllib3","nvra":"python3-urllib3-1.26.5-3.el9.noarch","release":"3.el9","srpm_name":"python-urllib3","srpm_nevra":"python-urllib3-0:1.26.5-3.el9.src","summary":"Python3 HTTP library with thread-safe connection pooling and file post","version":"1.26.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-requests","nvra":"python3-requests-2.25.1-6.el9.noarch","release":"6.el9","srpm_name":"python-requests","srpm_nevra":"python-requests-0:2.25.1-6.el9.src","summary":"HTTP library, written in Python, for human beings","version":"2.25.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-cloud-what","nvra":"python3-cloud-what-1.29.26-3.el9_0.x86_64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Python package for detection of public cloud provider","version":"1.29.26"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dmidecode","nvra":"dmidecode-3.3-7.el9.x86_64","release":"7.el9","srpm_name":"dmidecode","srpm_nevra":"dmidecode-1:3.3-7.el9.src","summary":"Tool to analyse BIOS DMI data","version":"3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-53.el9.x86_64","release":"53.el9","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-53.el9.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libeconf","nvra":"libeconf-0.4.1-2.el9.x86_64","release":"2.el9","srpm_name":"libeconf","srpm_nevra":"libeconf-0:0.4.1-2.el9.src","summary":"Enhanced config file parser library","version":"0.4.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.4-8.el9.x86_64","release":"8.el9","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.4-8.el9.src","summary":"A library for password generation and password quality checking","version":"1.4.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.5.1-9.el9.x86_64","release":"9.el9","srpm_name":"pam","srpm_nevra":"pam-0:1.5.1-9.el9.src","summary":"An extensible library which provides authentication for applications","version":"1.5.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.37.4-3.el9.x86_64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"A collection of basic system utilities","version":"2.37.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libgomp","nvra":"libgomp-11.2.1-9.4.el9.x86_64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC OpenMP v4.5 shared support library","version":"11.2.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.43.0-5.el9.x86_64","release":"5.el9","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.43.0-5.el9.src","summary":"A library implementing the HTTP/2 protocol","version":"1.43.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.5.0-10.el9.x86_64","release":"10.el9","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.5.0-10.el9.src","summary":"Convenience library for kernel netlink sockets","version":"3.5.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.15-2.el9.x86_64","release":"2.el9","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.15-2.el9.src","summary":"Python module to interface with ethtool","version":"0.15"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.5.2-2.el9.x86_64","release":"2.el9","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.5.2-2.el9.src","summary":"Enhanced seccomp library","version":"2.5.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.183-4.el9.x86_64","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device mapper utility","version":"1.02.183"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.183-4.el9.x86_64","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device-mapper shared library","version":"1.02.183"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.4.3-4.el9.x86_64","release":"4.el9","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.4.3-4.el9.src","summary":"Cryptsetup shared library","version":"2.4.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.20-5.el9.x86_64","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus","version":"1.12.20"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-250-6.el9_0.x86_64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd PAM module","version":"250"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-250-6.el9_0.x86_64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"System and Service Manager","version":"250"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.20-5.el9.noarch","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus configuration","version":"1.12.20"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"dbus-broker","nvra":"dbus-broker-28-5.el9.x86_64","release":"5.el9","srpm_name":"dbus-broker","srpm_nevra":"dbus-broker-0:28-5.el9.src","summary":"Linux D-Bus Message Broker","version":"28"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.186-1.el9.noarch","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Default yama attach scope sysctl setting","version":"0.186"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.186-1.el9.x86_64","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Libraries to handle compiled objects","version":"0.186"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.2-3.el9.x86_64","release":"3.el9","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.2-3.el9.src","summary":"Main loop abstraction library","version":"0.3.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.19.1-15.el9_0.x86_64","release":"15.el9_0","srpm_name":"krb5","srpm_nevra":"krb5-0:1.19.1-15.el9_0.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.19.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libcurl-minimal","nvra":"libcurl-minimal-7.76.1-14.el9.x86_64","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of libcurl for minimal installations","version":"7.76.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"curl-minimal","nvra":"curl-minimal-7.76.1-14.el9.x86_64","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of curl for minimal installations","version":"7.76.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.16.1.3-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"The RPM package management system","version":"4.16.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.16.1.3-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for manipulating RPM packages","version":"4.16.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.7.20-2.el9.x86_64","release":"2.el9","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.7.20-2.el9.src","summary":"Package dependency solver","version":"0.7.20"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.16.1.3-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for building RPM packages","version":"4.16.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"tpm2-tss","nvra":"tpm2-tss-3.0.3-7.el9.x86_64","release":"7.el9","srpm_name":"tpm2-tss","srpm_nevra":"tpm2-tss-0:3.0.3-7.el9.src","summary":"TPM2.0 Software Stack","version":"3.0.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.4-4.el9.x86_64","release":"4.el9","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.4-4.el9.src","summary":"IMA/EVM support utilities","version":"1.4"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-20.el9.x86_64","release":"20.el9","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-20.el9.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.59-4.el9_0.x86_64","release":"4.el9_0","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.59-4.el9_0.src","summary":"LDAP support libraries","version":"2.4.59"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.63-10.el9.x86_64","release":"10.el9","srpm_name":"libuser","srpm_nevra":"libuser-0:0.63-10.el9.src","summary":"A user and group account administration library","version":"0.63"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-12.el9.x86_64","release":"12.el9","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-12.el9.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.114-4.el9.x86_64","release":"4.el9","srpm_name":"usermode","srpm_nevra":"usermode-0:1.114-4.el9.src","summary":"Tools for certain user account management tasks","version":"1.114"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.2.5-7.el9.x86_64","release":"7.el9","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.2.5-7.el9.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.2.5"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libmodulemd","nvra":"libmodulemd-2.13.0-2.el9.x86_64","release":"2.el9","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.13.0-2.el9.src","summary":"Module metadata manipulation library","version":"2.13.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.6-8.el9.x86_64","release":"8.el9","srpm_name":"npth","srpm_nevra":"npth-0:1.6-8.el9.src","summary":"The New GNU Portable Threads library","version":"1.6"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.3.3-1.el9.x86_64","release":"1.el9","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.3.3-1.el9.src","summary":"Utility for secure communication and data storage","version":"2.3.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.15.1-6.el9.x86_64","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.15.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.14.2-1.el9.x86_64","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Repodata downloading library","version":"1.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.65.0-5.el9_0.x86_64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.65.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.65.0-5.el9_0.x86_64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.65.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.65.0-5.el9_0.x86_64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.65.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.14.2-1.el9.x86_64","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Python 3 bindings for the librepo library","version":"1.14.2"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.15.1-6.el9.x86_64","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"gpgme bindings for Python 3","version":"1.15.1"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"rpm-sign-libs","nvra":"rpm-sign-libs-4.16.1.3-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for signing RPM packages","version":"4.16.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.16.1.3-12.el9_0.x86_64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.16.1.3"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.29.26-3.el9_0.x86_64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-27.el9.x86_64","release":"27.el9","srpm_name":"which","srpm_nevra":"which-0:2.21-27.el9.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.21-2.el9.2.x86_64","release":"2.el9.2","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.21-2.el9.2.src","summary":"Detect if we are running in a virtual machine","version":"1.21"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.15.2-6.el9.noarch","release":"6.el9","srpm_name":"libreport","srpm_nevra":"libreport-0:2.15.2-6.el9.src","summary":"Filesystem layout for libreport","version":"2.15.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Common data and configuration files for DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Python 3 interface to DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"libdnf-plugin-subscription-manager","nvra":"libdnf-plugin-subscription-manager-1.29.26-3.el9_0.x86_64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Subscription Manager plugin for libdnf","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.24-4.el9_0.noarch","release":"4.el9_0","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.24-4.el9_0.src","summary":"Core Plugins for DNF","version":"4.0.24"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"fonts-filesystem","nvra":"fonts-filesystem-2.0.5-7.el9.1.noarch","release":"7.el9.1","srpm_name":"fonts-rpm-macros","srpm_nevra":"fonts-rpm-macros-1:2.0.5-7.el9.1.src","summary":"Directories used by font packages","version":"2.0.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dejavu-sans-fonts","nvra":"dejavu-sans-fonts-2.37-18.el9.noarch","release":"18.el9","srpm_name":"dejavu-fonts","srpm_nevra":"dejavu-fonts-0:2.37-18.el9.src","summary":"DejaVu Sans, a variable-width sans-serif font family","version":"2.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-font-en","nvra":"langpacks-core-font-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English core font meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-en","nvra":"langpacks-core-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks core meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks meta-package","version":"3.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.29.26-3.el9_0.x86_64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Tools and libraries for subscription and repository management","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies-scripts","nvra":"crypto-policies-scripts-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"Tool to switch between crypto policies","version":"20220223"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.8.0-5.el9.x86_64","release":"5.el9","srpm_name":"findutils","srpm_nevra":"findutils-1:4.8.0-5.el9.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.8.0"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.34-3.el9.x86_64","release":"3.el9","srpm_name":"tar","srpm_nevra":"tar-2:1.34-3.el9.src","summary":"GNU file archiving program","version":"1.34"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.2.2637-15.el9.x86_64","release":"15.el9","srpm_name":"vim","srpm_nevra":"vim-2:8.2.2637-15.el9.src","summary":"A minimal version of the VIM editor","version":"8.2.2637"},{"architecture":"x86_64","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-10.2-9.el9.x86_64","release":"9.el9","srpm_name":"gdb","srpm_nevra":"gdb-0:10.2-9.el9.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"10.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"rootfiles","nvra":"rootfiles-8.1-31.el9.noarch","release":"31.el9","srpm_name":"rootfiles","srpm_nevra":"rootfiles-0:8.1-31.el9.src","summary":"The basic required files for the root user's directory","version":"8.1"}],"_links":{"image":{"href":"/v1/images/id/6270e0fc80cc9b3025076e80"}}} +-- catalog.redhat.com/api/containers/v1/images/id/6270e0ff80cc9b3025076e8c/rpm-manifest -- +{"_id":"6270e10080cc9b3025076e92","creation_date":"2022-05-03T08:00:00.768000+00:00","image_id":"6270e0ff80cc9b3025076e8c","last_update_date":"2023-06-04T00:33:44.818000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-11.2.1-9.4.el9.ppc64le","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC version 11 shared support library","version":"11.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"System-wide crypto policies","version":"20220223"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2022a-1.el9_0.noarch","release":"1.el9_0","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2022a-1.el9_0.src","summary":"Timezone data","version":"2022a"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.29.26-3.el9_0.ppc64le","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-9.0-2.17.el9.ppc64le","release":"2.17.el9","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:9.0-2.17.el9.src","summary":"Red Hat Enterprise Linux release file","version":"9.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.13.7-6.el9.noarch","release":"6.el9","srpm_name":"setup","srpm_nevra":"setup-0:2.13.7-6.el9.src","summary":"A set of system configuration and setup files","version":"2.13.7"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.16-2.el9.ppc64le","release":"2.el9","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.16-2.el9.src","summary":"The basic directory layout for a Linux system","version":"3.16"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-13.el9.noarch","release":"13.el9","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-13.el9.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools-wheel","nvra":"python3-setuptools-wheel-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"The setuptools wheel","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pcre2-syntax","nvra":"pcre2-syntax-10.37-3.el9.1.noarch","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Documentation for PCRE2 regular expressions","version":"10.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.2-8.20210508.el9.noarch","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Descriptions of common terminals","version":"6.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.34-28.el9_0.ppc64le","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Minimal language packs for glibc.","version":"2.34"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.34-28.el9_0.ppc64le","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Common binaries and locale data for glibc","version":"2.34"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.34-28.el9_0.ppc64le","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"The GNU libc libraries","version":"2.34"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.2-8.20210508.el9.ppc64le","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Ncurses libraries","version":"6.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-5.1.8-4.el9.ppc64le","release":"4.el9","srpm_name":"bash","srpm_nevra":"bash-0:5.1.8-4.el9.src","summary":"The GNU Bourne Again shell","version":"5.1.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-31.el9_0.1.ppc64le","release":"31.el9_0.1","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-31.el9_0.1.src","summary":"Compression and decompression library","version":"1.2.11"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.5-7.el9.ppc64le","release":"7.el9","srpm_name":"xz","srpm_nevra":"xz-0:5.2.5-7.el9.src","summary":"Libraries for decoding LZMA compression","version":"5.2.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.8-8.el9.ppc64le","release":"8.el9","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.8-8.el9.src","summary":"Libraries for applications using bzip2","version":"1.0.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libzstd","nvra":"libzstd-1.5.1-2.el9.ppc64le","release":"2.el9","srpm_name":"zstd","srpm_nevra":"zstd-0:1.5.1-2.el9.src","summary":"Zstd shared library","version":"1.5.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.4.18-3.el9.ppc64le","release":"3.el9","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.4.18-3.el9.src","summary":"Extended crypt library for descrypt, md5crypt, bcrypt, and others","version":"4.4.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.48-8.el9.ppc64le","release":"8.el9","srpm_name":"libcap","srpm_nevra":"libcap-0:2.48-8.el9.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.48"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.34.1-5.el9.ppc64le","release":"5.el9","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.34.1-5.el9.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.34.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Universally unique ID library","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.18-8.el9.ppc64le","release":"8.el9","srpm_name":"popt","srpm_nevra":"popt-0:1.18-8.el9.src","summary":"C library for parsing command line parameters","version":"1.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.4.2-7.el9.ppc64le","release":"7.el9","srpm_name":"libffi","srpm_nevra":"libffi-0:3.4.2-7.el9.src","summary":"A portable foreign function interface library","version":"3.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.24.1-2.el9.ppc64le","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.24.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.42-5.el9.ppc64le","release":"5.el9","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.42-5.el9.src","summary":"Library for error values used by GnuPG components","version":"1.42"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.13-1.el9.ppc64le","release":"1.el9","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.13-1.el9.src","summary":"Library providing XML and HTML support","version":"2.9.13"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-8.1-4.el9.ppc64le","release":"4.el9","srpm_name":"readline","srpm_nevra":"readline-0:8.1-4.el9.src","summary":"A library for editing typed command lines","version":"8.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.2.0-10.el9.ppc64le","release":"10.el9","srpm_name":"gmp","srpm_nevra":"gmp-1:6.2.0-10.el9.src","summary":"A GNU arbitrary precision library","version":"6.2.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.14-11.el9.ppc64le","release":"11.el9","srpm_name":"json-c","srpm_nevra":"json-c-0:0.14-11.el9.src","summary":"JSON implementation in C","version":"0.14"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Formatting library for ls-like programs.","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-11.2.1-9.4.el9.ppc64le","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GNU Standard C++ Library","version":"11.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.4.2-4.el9.ppc64le","release":"4.el9","srpm_name":"lua","srpm_nevra":"lua-0:5.4.2-4.el9.src","summary":"Libraries for lua","version":"5.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.10.0-2.el9.ppc64le","release":"2.el9","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.10.0-2.el9.src","summary":"A general-purpose cryptography library","version":"1.10.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.186-1.el9.ppc64le","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Library to read and write ELF files","version":"0.186"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.39-8.el9.ppc64le","release":"8.el9","srpm_name":"file","srpm_nevra":"file-0:5.39-8.el9.src","summary":"Libraries for applications using libmagic","version":"5.39"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.10-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"expat","srpm_nevra":"expat-0:2.2.10-12.el9_0.src","summary":"An XML parser library","version":"2.2.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.5.1-3.el9.ppc64le","release":"3.el9","srpm_name":"attr","srpm_nevra":"attr-0:2.5.1-3.el9.src","summary":"Dynamic library for extended attribute support","version":"2.5.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.3.1-3.el9.ppc64le","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Dynamic library for access control list support","version":"2.3.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.8.2-7.el9.ppc64le","release":"7.el9","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.8.2-7.el9.src","summary":"Alternate posix capabilities library","version":"0.8.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0.7-101.el9_0.2.ppc64le","release":"101.el9_0.2","srpm_name":"audit","srpm_nevra":"audit-0:3.0.7-101.el9_0.2.src","summary":"Dynamic library for libaudit","version":"3.0.7"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.46.5-2.el9.ppc64le","release":"2.el9","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.46.5-2.el9.src","summary":"Common error description library","version":"1.46.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.9.3-5.el9.ppc64le","release":"5.el9","srpm_name":"lz4","srpm_nevra":"lz4-0:1.9.3-5.el9.src","summary":"Libaries for lz4","version":"1.9.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.5-3.el9.ppc64le","release":"3.el9","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.5-3.el9.src","summary":"GnuPG IPC library","version":"2.5.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.19-4.el9.ppc64le","release":"4.el9","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.19-4.el9.src","summary":"Libraries files for gdbm","version":"1.19"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.6.1-4.el9.ppc64le","release":"4.el9","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.6.1-4.el9.src","summary":"Key utilities library","version":"1.6.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-3.3-2.el9.ppc64le","release":"2.el9","srpm_name":"libsepol","srpm_nevra":"libsepol-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.13-4.el9.ppc64le","release":"4.el9","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.13-4.el9.src","summary":"Library for handling page faults in user mode","version":"2.13"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.16.0-7.el9.ppc64le","release":"7.el9","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.16.0-7.el9.src","summary":"The ASN.1 library used in GNUTLS","version":"4.16.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.10-15.el9.ppc64le","release":"15.el9","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.10-15.el9.src","summary":"GNU Unicode string library","version":"0.9.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.44-3.el9.3.ppc64le","release":"3.el9.3","srpm_name":"pcre","srpm_nevra":"pcre-0:8.44-3.el9.3.src","summary":"Perl-compatible regular expression library","version":"8.44"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.6-5.el9.ppc64le","release":"5.el9","srpm_name":"grep","srpm_nevra":"grep-0:3.6-5.el9.src","summary":"Pattern matching utilities","version":"3.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.37-3.el9.1.ppc64le","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Perl-compatible regular expression library","version":"10.37"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-3.3-2.el9.ppc64le","release":"2.el9","srpm_name":"libselinux","srpm_nevra":"libselinux-0:3.3-2.el9.src","summary":"SELinux library and simple utilities","version":"3.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.32-31.el9.ppc64le","release":"31.el9","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.32-31.el9.src","summary":"coreutils multicall binary","version":"8.32"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Block device ID library","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Device mounting library","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.8-9.el9.ppc64le","release":"9.el9","srpm_name":"sed","srpm_nevra":"sed-0:4.8-9.el9.src","summary":"A GNU stream text editor","version":"4.8"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Partitioning library for fdisk-like programs.","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.10-9.el9_0.ppc64le","release":"9.el9_0","srpm_name":"gzip","srpm_nevra":"gzip-0:1.10-9.el9_0.src","version":"1.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-27.el9.ppc64le","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cracklib-dicts","nvra":"cracklib-dicts-2.9.6-27.el9.ppc64le","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"The standard CrackLib dictionaries","version":"2.9.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-3.3-2.el9.ppc64le","release":"2.el9","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.9-3.el9.ppc64le","release":"3.el9","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.9-3.el9.src","summary":"Utilities for managing accounts and shadow password files","version":"4.9"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.2.1-6.el9.ppc64le","release":"6.el9","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.2.1-6.el9.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.3.0-7.el9.ppc64le","release":"7.el9","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.3.0-7.el9.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.3.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.3.1-3.el9.ppc64le","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Access control list utilities","version":"2.3.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.18-1.el9.ppc64le","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Comps XML file manipulation library","version":"0.1.18"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-4.1.0-7.el9.ppc64le","release":"7.el9","srpm_name":"mpfr","srpm_nevra":"mpfr-0:4.1.0-7.el9.src","summary":"C library for multiple-precision floating-point computations","version":"4.1.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-5.1.0-6.el9.ppc64le","release":"6.el9","srpm_name":"gawk","srpm_nevra":"gawk-0:5.1.0-6.el9.src","summary":"The GNU version of the AWK text processing utility","version":"5.1.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.7.3-2.el9.ppc64le","release":"2.el9","srpm_name":"nettle","srpm_nevra":"nettle-0:3.7.3-2.el9.src","summary":"A low-level cryptographic library","version":"3.7.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.5.1-4.el9.ppc64le","release":"4.el9","srpm_name":"libksba","srpm_nevra":"libksba-0:1.5.1-4.el9.src","summary":"CMS and X.509 library","version":"1.5.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"systemd-rpm-macros","nvra":"systemd-rpm-macros-250-6.el9_0.noarch","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"Macros that define paths and scriptlets related to systemd","version":"250"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"alternatives","nvra":"alternatives-1.20-2.el9.ppc64le","release":"2.el9","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.20-2.el9.src","summary":"A tool to maintain symbolic links determining default commands","version":"1.20"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.24.1-2.el9.ppc64le","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"System trust module from p11-kit","version":"0.24.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2020.2.50-94.el9.noarch","release":"94.el9","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2020.2.50-94.el9.src","summary":"The Mozilla CA root certificate bundle","version":"2020.2.50"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-3.0.1-23.el9_0.ppc64le","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"A general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-250-6.el9_0.ppc64le","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd libraries","version":"250"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.7.3-9.el9.ppc64le","release":"9.el9","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.7.3-9.el9.src","summary":"A TLS protocol implementation","version":"3.7.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.68.4-5.el9.ppc64le","release":"5.el9","srpm_name":"glib2","srpm_nevra":"glib2-0:2.68.4-5.el9.src","summary":"A library of handy utility functions","version":"2.68.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.68.0-10.el9.ppc64le","release":"10.el9","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.68.0-10.el9.src","summary":"Introspection system for GObject-based libraries","version":"1.68.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.6.6-1.el9.ppc64le","release":"1.el9","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.6.6-1.el9.src","summary":"Library for JavaScript Object Notation format","version":"1.6.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-7.el9.ppc64le","release":"7.el9","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-7.el9.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.20-5.el9.ppc64le","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"Libraries for accessing D-BUS","version":"1.12.20"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"util-linux-core","nvra":"util-linux-core-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"The most essential utilities from the util-linux suite.","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-28-7.el9.ppc64le","release":"7.el9","srpm_name":"kmod","srpm_nevra":"kmod-0:28-7.el9.src","summary":"Libraries to handle kernel module loading and unloading","version":"28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.5.3-1.el9.ppc64le","release":"1.el9","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.5.3-1.el9.src","summary":"A library for handling streaming archive formats","version":"3.5.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"openssl","nvra":"openssl-3.0.1-23.el9_0.ppc64le","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"Utilities from the general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pip-wheel","nvra":"python3-pip-wheel-21.2.3-6.el9.noarch","release":"6.el9","srpm_name":"python-pip","srpm_nevra":"python-pip-0:21.2.3-6.el9.src","summary":"The pip wheel","version":"21.2.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3","nvra":"python3-3.9.10-2.el9.ppc64le","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python 3.9 interpreter","version":"3.9.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.9.10-2.el9.ppc64le","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python runtime libraries","version":"3.9.10"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.18-2.el9.ppc64le","release":"2.el9","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.18-2.el9.src","summary":"D-Bus bindings for python3","version":"1.2.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.15.0-9.el9.noarch","release":"9.el9","srpm_name":"python-six","srpm_nevra":"python-six-0:1.15.0-9.el9.src","summary":"Python 2 and 3 compatibility utilities","version":"1.15.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.8.1-6.el9.noarch","release":"6.el9","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.8.1-6.el9.src","summary":"Powerful extensions to the standard datetime module","version":"2.8.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-45.el9.noarch","release":"45.el9","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-45.el9.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-idna","nvra":"python3-idna-2.10-7.el9.noarch","release":"7.el9","srpm_name":"python-idna","srpm_nevra":"python-idna-0:2.10-7.el9.src","summary":"Internationalized Domain Names in Applications (IDNA)","version":"2.10"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools","nvra":"python3-setuptools-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"Easily build and distribute Python 3 packages","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-25.el9.noarch","release":"25.el9","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-25.el9.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.18-1.el9.ppc64le","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Python 3 bindings for libcomps library","version":"0.1.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-chardet","nvra":"python3-chardet-4.0.0-5.el9.noarch","release":"5.el9","srpm_name":"python-chardet","srpm_nevra":"python-chardet-0:4.0.0-5.el9.src","summary":"Character encoding auto-detection in Python","version":"4.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.4.2-6.el9.noarch","release":"6.el9","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.4.2-6.el9.src","summary":"Module to simplify usage of decorators in python3","version":"4.4.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.40.1-5.el9.ppc64le","release":"5.el9","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.40.1-5.el9.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.40.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pysocks","nvra":"python3-pysocks-1.7.1-12.el9.noarch","release":"12.el9","srpm_name":"python-pysocks","srpm_nevra":"python-pysocks-0:1.7.1-12.el9.src","summary":"A Python SOCKS client module","version":"1.7.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-urllib3","nvra":"python3-urllib3-1.26.5-3.el9.noarch","release":"3.el9","srpm_name":"python-urllib3","srpm_nevra":"python-urllib3-0:1.26.5-3.el9.src","summary":"Python3 HTTP library with thread-safe connection pooling and file post","version":"1.26.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-requests","nvra":"python3-requests-2.25.1-6.el9.noarch","release":"6.el9","srpm_name":"python-requests","srpm_nevra":"python-requests-0:2.25.1-6.el9.src","summary":"HTTP library, written in Python, for human beings","version":"2.25.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-cloud-what","nvra":"python3-cloud-what-1.29.26-3.el9_0.ppc64le","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Python package for detection of public cloud provider","version":"1.29.26"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-53.el9.ppc64le","release":"53.el9","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-53.el9.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libeconf","nvra":"libeconf-0.4.1-2.el9.ppc64le","release":"2.el9","srpm_name":"libeconf","srpm_nevra":"libeconf-0:0.4.1-2.el9.src","summary":"Enhanced config file parser library","version":"0.4.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.4-8.el9.ppc64le","release":"8.el9","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.4-8.el9.src","summary":"A library for password generation and password quality checking","version":"1.4.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.5.1-9.el9.ppc64le","release":"9.el9","srpm_name":"pam","srpm_nevra":"pam-0:1.5.1-9.el9.src","summary":"An extensible library which provides authentication for applications","version":"1.5.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libgomp","nvra":"libgomp-11.2.1-9.4.el9.ppc64le","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC OpenMP v4.5 shared support library","version":"11.2.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.43.0-5.el9.ppc64le","release":"5.el9","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.43.0-5.el9.src","summary":"A library implementing the HTTP/2 protocol","version":"1.43.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.5.0-10.el9.ppc64le","release":"10.el9","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.5.0-10.el9.src","summary":"Convenience library for kernel netlink sockets","version":"3.5.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.15-2.el9.ppc64le","release":"2.el9","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.15-2.el9.src","summary":"Python module to interface with ethtool","version":"0.15"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"librtas","nvra":"librtas-2.0.2-14.el9.ppc64le","release":"14.el9","srpm_name":"librtas","srpm_nevra":"librtas-0:2.0.2-14.el9.src","summary":"Libraries to provide access to RTAS calls and RTAS events","version":"2.0.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.37.4-3.el9.ppc64le","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"A collection of basic system utilities","version":"2.37.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.5.2-2.el9.ppc64le","release":"2.el9","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.5.2-2.el9.src","summary":"Enhanced seccomp library","version":"2.5.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.183-4.el9.ppc64le","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device mapper utility","version":"1.02.183"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.183-4.el9.ppc64le","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device-mapper shared library","version":"1.02.183"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.4.3-4.el9.ppc64le","release":"4.el9","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.4.3-4.el9.src","summary":"Cryptsetup shared library","version":"2.4.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.20-5.el9.ppc64le","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus","version":"1.12.20"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-250-6.el9_0.ppc64le","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd PAM module","version":"250"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-250-6.el9_0.ppc64le","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"System and Service Manager","version":"250"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.20-5.el9.noarch","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus configuration","version":"1.12.20"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"dbus-broker","nvra":"dbus-broker-28-5.el9.ppc64le","release":"5.el9","srpm_name":"dbus-broker","srpm_nevra":"dbus-broker-0:28-5.el9.src","summary":"Linux D-Bus Message Broker","version":"28"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.186-1.el9.noarch","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Default yama attach scope sysctl setting","version":"0.186"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.186-1.el9.ppc64le","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Libraries to handle compiled objects","version":"0.186"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.2-3.el9.ppc64le","release":"3.el9","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.2-3.el9.src","summary":"Main loop abstraction library","version":"0.3.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.19.1-15.el9_0.ppc64le","release":"15.el9_0","srpm_name":"krb5","srpm_nevra":"krb5-0:1.19.1-15.el9_0.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.19.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libcurl-minimal","nvra":"libcurl-minimal-7.76.1-14.el9.ppc64le","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of libcurl for minimal installations","version":"7.76.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"curl-minimal","nvra":"curl-minimal-7.76.1-14.el9.ppc64le","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of curl for minimal installations","version":"7.76.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.16.1.3-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"The RPM package management system","version":"4.16.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.16.1.3-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for manipulating RPM packages","version":"4.16.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.7.20-2.el9.ppc64le","release":"2.el9","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.7.20-2.el9.src","summary":"Package dependency solver","version":"0.7.20"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.16.1.3-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for building RPM packages","version":"4.16.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"tpm2-tss","nvra":"tpm2-tss-3.0.3-7.el9.ppc64le","release":"7.el9","srpm_name":"tpm2-tss","srpm_nevra":"tpm2-tss-0:3.0.3-7.el9.src","summary":"TPM2.0 Software Stack","version":"3.0.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.4-4.el9.ppc64le","release":"4.el9","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.4-4.el9.src","summary":"IMA/EVM support utilities","version":"1.4"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-20.el9.ppc64le","release":"20.el9","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-20.el9.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.59-4.el9_0.ppc64le","release":"4.el9_0","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.59-4.el9_0.src","summary":"LDAP support libraries","version":"2.4.59"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.63-10.el9.ppc64le","release":"10.el9","srpm_name":"libuser","srpm_nevra":"libuser-0:0.63-10.el9.src","summary":"A user and group account administration library","version":"0.63"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-12.el9.ppc64le","release":"12.el9","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-12.el9.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.114-4.el9.ppc64le","release":"4.el9","srpm_name":"usermode","srpm_nevra":"usermode-0:1.114-4.el9.src","summary":"Tools for certain user account management tasks","version":"1.114"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.2.5-7.el9.ppc64le","release":"7.el9","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.2.5-7.el9.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.2.5"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libmodulemd","nvra":"libmodulemd-2.13.0-2.el9.ppc64le","release":"2.el9","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.13.0-2.el9.src","summary":"Module metadata manipulation library","version":"2.13.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.6-8.el9.ppc64le","release":"8.el9","srpm_name":"npth","srpm_nevra":"npth-0:1.6-8.el9.src","summary":"The New GNU Portable Threads library","version":"1.6"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.3.3-1.el9.ppc64le","release":"1.el9","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.3.3-1.el9.src","summary":"Utility for secure communication and data storage","version":"2.3.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.15.1-6.el9.ppc64le","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.15.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.14.2-1.el9.ppc64le","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Repodata downloading library","version":"1.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.65.0-5.el9_0.ppc64le","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.65.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.65.0-5.el9_0.ppc64le","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.65.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.65.0-5.el9_0.ppc64le","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.65.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.14.2-1.el9.ppc64le","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Python 3 bindings for the librepo library","version":"1.14.2"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.15.1-6.el9.ppc64le","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"gpgme bindings for Python 3","version":"1.15.1"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"rpm-sign-libs","nvra":"rpm-sign-libs-4.16.1.3-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for signing RPM packages","version":"4.16.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.16.1.3-12.el9_0.ppc64le","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.16.1.3"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.29.26-3.el9_0.ppc64le","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-27.el9.ppc64le","release":"27.el9","srpm_name":"which","srpm_nevra":"which-0:2.21-27.el9.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.21-2.el9.2.ppc64le","release":"2.el9.2","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.21-2.el9.2.src","summary":"Detect if we are running in a virtual machine","version":"1.21"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.15.2-6.el9.noarch","release":"6.el9","srpm_name":"libreport","srpm_nevra":"libreport-0:2.15.2-6.el9.src","summary":"Filesystem layout for libreport","version":"2.15.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Common data and configuration files for DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Python 3 interface to DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"libdnf-plugin-subscription-manager","nvra":"libdnf-plugin-subscription-manager-1.29.26-3.el9_0.ppc64le","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Subscription Manager plugin for libdnf","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.24-4.el9_0.noarch","release":"4.el9_0","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.24-4.el9_0.src","summary":"Core Plugins for DNF","version":"4.0.24"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"fonts-filesystem","nvra":"fonts-filesystem-2.0.5-7.el9.1.noarch","release":"7.el9.1","srpm_name":"fonts-rpm-macros","srpm_nevra":"fonts-rpm-macros-1:2.0.5-7.el9.1.src","summary":"Directories used by font packages","version":"2.0.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dejavu-sans-fonts","nvra":"dejavu-sans-fonts-2.37-18.el9.noarch","release":"18.el9","srpm_name":"dejavu-fonts","srpm_nevra":"dejavu-fonts-0:2.37-18.el9.src","summary":"DejaVu Sans, a variable-width sans-serif font family","version":"2.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-font-en","nvra":"langpacks-core-font-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English core font meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-en","nvra":"langpacks-core-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks core meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks meta-package","version":"3.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.29.26-3.el9_0.ppc64le","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Tools and libraries for subscription and repository management","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies-scripts","nvra":"crypto-policies-scripts-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"Tool to switch between crypto policies","version":"20220223"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.8.0-5.el9.ppc64le","release":"5.el9","srpm_name":"findutils","srpm_nevra":"findutils-1:4.8.0-5.el9.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.8.0"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.34-3.el9.ppc64le","release":"3.el9","srpm_name":"tar","srpm_nevra":"tar-2:1.34-3.el9.src","summary":"GNU file archiving program","version":"1.34"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.2.2637-15.el9.ppc64le","release":"15.el9","srpm_name":"vim","srpm_nevra":"vim-2:8.2.2637-15.el9.src","summary":"A minimal version of the VIM editor","version":"8.2.2637"},{"architecture":"ppc64le","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-10.2-9.el9.ppc64le","release":"9.el9","srpm_name":"gdb","srpm_nevra":"gdb-0:10.2-9.el9.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"10.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"rootfiles","nvra":"rootfiles-8.1-31.el9.noarch","release":"31.el9","srpm_name":"rootfiles","srpm_nevra":"rootfiles-0:8.1-31.el9.src","summary":"The basic required files for the root user's directory","version":"8.1"}],"_links":{"image":{"href":"/v1/images/id/6270e0ff80cc9b3025076e8c"}}} +-- catalog.redhat.com/api/containers/v1/images/id/6270e10180cc9b3025076e97/rpm-manifest -- +{"_id":"6270e10380cc9b3025076e9d","creation_date":"2022-05-03T08:00:03.050000+00:00","image_id":"6270e10180cc9b3025076e97","last_update_date":"2023-06-04T00:33:45.107000+00:00","object_type":"containerImageRPMManifest","rpms":[{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgcc","nvra":"libgcc-11.2.1-9.4.el9.aarch64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC version 11 shared support library","version":"11.2.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies","nvra":"crypto-policies-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"System-wide crypto policies","version":"20220223"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"tzdata","nvra":"tzdata-2022a-1.el9_0.noarch","release":"1.el9_0","srpm_name":"tzdata","srpm_nevra":"tzdata-0:2022a-1.el9_0.src","summary":"Timezone data","version":"2022a"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"subscription-manager-rhsm-certificates","nvra":"subscription-manager-rhsm-certificates-1.29.26-3.el9_0.aarch64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Certificates required to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"redhat-release","nvra":"redhat-release-9.0-2.17.el9.aarch64","release":"2.17.el9","srpm_name":"redhat-release","srpm_nevra":"redhat-release-0:9.0-2.17.el9.src","summary":"Red Hat Enterprise Linux release file","version":"9.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"setup","nvra":"setup-2.13.7-6.el9.noarch","release":"6.el9","srpm_name":"setup","srpm_nevra":"setup-0:2.13.7-6.el9.src","summary":"A set of system configuration and setup files","version":"2.13.7"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"filesystem","nvra":"filesystem-3.16-2.el9.aarch64","release":"2.el9","srpm_name":"filesystem","srpm_nevra":"filesystem-0:3.16-2.el9.src","summary":"The basic directory layout for a Linux system","version":"3.16"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"basesystem","nvra":"basesystem-11-13.el9.noarch","release":"13.el9","srpm_name":"basesystem","srpm_nevra":"basesystem-0:11-13.el9.src","summary":"The skeleton package which defines a simple Red Hat Enterprise Linux system","version":"11"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools-wheel","nvra":"python3-setuptools-wheel-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"The setuptools wheel","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"pcre2-syntax","nvra":"pcre2-syntax-10.37-3.el9.1.noarch","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Documentation for PCRE2 regular expressions","version":"10.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ncurses-base","nvra":"ncurses-base-6.2-8.20210508.el9.noarch","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Descriptions of common terminals","version":"6.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc-minimal-langpack","nvra":"glibc-minimal-langpack-2.34-28.el9_0.aarch64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Minimal language packs for glibc.","version":"2.34"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc-common","nvra":"glibc-common-2.34-28.el9_0.aarch64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"Common binaries and locale data for glibc","version":"2.34"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glibc","nvra":"glibc-2.34-28.el9_0.aarch64","release":"28.el9_0","srpm_name":"glibc","srpm_nevra":"glibc-0:2.34-28.el9_0.src","summary":"The GNU libc libraries","version":"2.34"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"ncurses-libs","nvra":"ncurses-libs-6.2-8.20210508.el9.aarch64","release":"8.20210508.el9","srpm_name":"ncurses","srpm_nevra":"ncurses-0:6.2-8.20210508.el9.src","summary":"Ncurses libraries","version":"6.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"bash","nvra":"bash-5.1.8-4.el9.aarch64","release":"4.el9","srpm_name":"bash","srpm_nevra":"bash-0:5.1.8-4.el9.src","summary":"The GNU Bourne Again shell","version":"5.1.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"zlib","nvra":"zlib-1.2.11-31.el9_0.1.aarch64","release":"31.el9_0.1","srpm_name":"zlib","srpm_nevra":"zlib-0:1.2.11-31.el9_0.1.src","summary":"Compression and decompression library","version":"1.2.11"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"xz-libs","nvra":"xz-libs-5.2.5-7.el9.aarch64","release":"7.el9","srpm_name":"xz","srpm_nevra":"xz-0:5.2.5-7.el9.src","summary":"Libraries for decoding LZMA compression","version":"5.2.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"bzip2-libs","nvra":"bzip2-libs-1.0.8-8.el9.aarch64","release":"8.el9","srpm_name":"bzip2","srpm_nevra":"bzip2-0:1.0.8-8.el9.src","summary":"Libraries for applications using bzip2","version":"1.0.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libzstd","nvra":"libzstd-1.5.1-2.el9.aarch64","release":"2.el9","srpm_name":"zstd","srpm_nevra":"zstd-0:1.5.1-2.el9.src","summary":"Zstd shared library","version":"1.5.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libxcrypt","nvra":"libxcrypt-4.4.18-3.el9.aarch64","release":"3.el9","srpm_name":"libxcrypt","srpm_nevra":"libxcrypt-0:4.4.18-3.el9.src","summary":"Extended crypt library for descrypt, md5crypt, bcrypt, and others","version":"4.4.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcap","nvra":"libcap-2.48-8.el9.aarch64","release":"8.el9","srpm_name":"libcap","srpm_nevra":"libcap-0:2.48-8.el9.src","summary":"Library for getting and setting POSIX.1e capabilities","version":"2.48"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"sqlite-libs","nvra":"sqlite-libs-3.34.1-5.el9.aarch64","release":"5.el9","srpm_name":"sqlite","srpm_nevra":"sqlite-0:3.34.1-5.el9.src","summary":"Shared library for the sqlite3 embeddable SQL database engine.","version":"3.34.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libuuid","nvra":"libuuid-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Universally unique ID library","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"popt","nvra":"popt-1.18-8.el9.aarch64","release":"8.el9","srpm_name":"popt","srpm_nevra":"popt-0:1.18-8.el9.src","summary":"C library for parsing command line parameters","version":"1.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libffi","nvra":"libffi-3.4.2-7.el9.aarch64","release":"7.el9","srpm_name":"libffi","srpm_nevra":"libffi-0:3.4.2-7.el9.src","summary":"A portable foreign function interface library","version":"3.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"p11-kit","nvra":"p11-kit-0.24.1-2.el9.aarch64","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"Library for loading and sharing PKCS#11 modules","version":"0.24.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgpg-error","nvra":"libgpg-error-1.42-5.el9.aarch64","release":"5.el9","srpm_name":"libgpg-error","srpm_nevra":"libgpg-error-0:1.42-5.el9.src","summary":"Library for error values used by GnuPG components","version":"1.42"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libxml2","nvra":"libxml2-2.9.13-1.el9.aarch64","release":"1.el9","srpm_name":"libxml2","srpm_nevra":"libxml2-0:2.9.13-1.el9.src","summary":"Library providing XML and HTML support","version":"2.9.13"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"readline","nvra":"readline-8.1-4.el9.aarch64","release":"4.el9","srpm_name":"readline","srpm_nevra":"readline-0:8.1-4.el9.src","summary":"A library for editing typed command lines","version":"8.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gmp","nvra":"gmp-6.2.0-10.el9.aarch64","release":"10.el9","srpm_name":"gmp","srpm_nevra":"gmp-1:6.2.0-10.el9.src","summary":"A GNU arbitrary precision library","version":"6.2.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"json-c","nvra":"json-c-0.14-11.el9.aarch64","release":"11.el9","srpm_name":"json-c","srpm_nevra":"json-c-0:0.14-11.el9.src","summary":"JSON implementation in C","version":"0.14"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsmartcols","nvra":"libsmartcols-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Formatting library for ls-like programs.","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libstdc++","nvra":"libstdc++-11.2.1-9.4.el9.aarch64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GNU Standard C++ Library","version":"11.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"lua-libs","nvra":"lua-libs-5.4.2-4.el9.aarch64","release":"4.el9","srpm_name":"lua","srpm_nevra":"lua-0:5.4.2-4.el9.src","summary":"Libraries for lua","version":"5.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgcrypt","nvra":"libgcrypt-1.10.0-2.el9.aarch64","release":"2.el9","srpm_name":"libgcrypt","srpm_nevra":"libgcrypt-0:1.10.0-2.el9.src","summary":"A general-purpose cryptography library","version":"1.10.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"elfutils-libelf","nvra":"elfutils-libelf-0.186-1.el9.aarch64","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Library to read and write ELF files","version":"0.186"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"file-libs","nvra":"file-libs-5.39-8.el9.aarch64","release":"8.el9","srpm_name":"file","srpm_nevra":"file-0:5.39-8.el9.src","summary":"Libraries for applications using libmagic","version":"5.39"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"expat","nvra":"expat-2.2.10-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"expat","srpm_nevra":"expat-0:2.2.10-12.el9_0.src","summary":"An XML parser library","version":"2.2.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libattr","nvra":"libattr-2.5.1-3.el9.aarch64","release":"3.el9","srpm_name":"attr","srpm_nevra":"attr-0:2.5.1-3.el9.src","summary":"Dynamic library for extended attribute support","version":"2.5.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libacl","nvra":"libacl-2.3.1-3.el9.aarch64","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Dynamic library for access control list support","version":"2.3.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcap-ng","nvra":"libcap-ng-0.8.2-7.el9.aarch64","release":"7.el9","srpm_name":"libcap-ng","srpm_nevra":"libcap-ng-0:0.8.2-7.el9.src","summary":"Alternate posix capabilities library","version":"0.8.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"audit-libs","nvra":"audit-libs-3.0.7-101.el9_0.2.aarch64","release":"101.el9_0.2","srpm_name":"audit","srpm_nevra":"audit-0:3.0.7-101.el9_0.2.src","summary":"Dynamic library for libaudit","version":"3.0.7"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcom_err","nvra":"libcom_err-1.46.5-2.el9.aarch64","release":"2.el9","srpm_name":"e2fsprogs","srpm_nevra":"e2fsprogs-0:1.46.5-2.el9.src","summary":"Common error description library","version":"1.46.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"lz4-libs","nvra":"lz4-libs-1.9.3-5.el9.aarch64","release":"5.el9","srpm_name":"lz4","srpm_nevra":"lz4-0:1.9.3-5.el9.src","summary":"Libaries for lz4","version":"1.9.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libassuan","nvra":"libassuan-2.5.5-3.el9.aarch64","release":"3.el9","srpm_name":"libassuan","srpm_nevra":"libassuan-0:2.5.5-3.el9.src","summary":"GnuPG IPC library","version":"2.5.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gdbm-libs","nvra":"gdbm-libs-1.19-4.el9.aarch64","release":"4.el9","srpm_name":"gdbm","srpm_nevra":"gdbm-1:1.19-4.el9.src","summary":"Libraries files for gdbm","version":"1.19"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"keyutils-libs","nvra":"keyutils-libs-1.6.1-4.el9.aarch64","release":"4.el9","srpm_name":"keyutils","srpm_nevra":"keyutils-0:1.6.1-4.el9.src","summary":"Key utilities library","version":"1.6.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsepol","nvra":"libsepol-3.3-2.el9.aarch64","release":"2.el9","srpm_name":"libsepol","srpm_nevra":"libsepol-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsigsegv","nvra":"libsigsegv-2.13-4.el9.aarch64","release":"4.el9","srpm_name":"libsigsegv","srpm_nevra":"libsigsegv-0:2.13-4.el9.src","summary":"Library for handling page faults in user mode","version":"2.13"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libtasn1","nvra":"libtasn1-4.16.0-7.el9.aarch64","release":"7.el9","srpm_name":"libtasn1","srpm_nevra":"libtasn1-0:4.16.0-7.el9.src","summary":"The ASN.1 library used in GNUTLS","version":"4.16.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libunistring","nvra":"libunistring-0.9.10-15.el9.aarch64","release":"15.el9","srpm_name":"libunistring","srpm_nevra":"libunistring-0:0.9.10-15.el9.src","summary":"GNU Unicode string library","version":"0.9.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pcre","nvra":"pcre-8.44-3.el9.3.aarch64","release":"3.el9.3","srpm_name":"pcre","srpm_nevra":"pcre-0:8.44-3.el9.3.src","summary":"Perl-compatible regular expression library","version":"8.44"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"grep","nvra":"grep-3.6-5.el9.aarch64","release":"5.el9","srpm_name":"grep","srpm_nevra":"grep-0:3.6-5.el9.src","summary":"Pattern matching utilities","version":"3.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pcre2","nvra":"pcre2-10.37-3.el9.1.aarch64","release":"3.el9.1","srpm_name":"pcre2","srpm_nevra":"pcre2-0:10.37-3.el9.1.src","summary":"Perl-compatible regular expression library","version":"10.37"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libselinux","nvra":"libselinux-3.3-2.el9.aarch64","release":"2.el9","srpm_name":"libselinux","srpm_nevra":"libselinux-0:3.3-2.el9.src","summary":"SELinux library and simple utilities","version":"3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"coreutils-single","nvra":"coreutils-single-8.32-31.el9.aarch64","release":"31.el9","srpm_name":"coreutils","srpm_nevra":"coreutils-0:8.32-31.el9.src","summary":"coreutils multicall binary","version":"8.32"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libblkid","nvra":"libblkid-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Block device ID library","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libmount","nvra":"libmount-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Device mounting library","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"sed","nvra":"sed-4.8-9.el9.aarch64","release":"9.el9","srpm_name":"sed","srpm_nevra":"sed-0:4.8-9.el9.src","summary":"A GNU stream text editor","version":"4.8"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libfdisk","nvra":"libfdisk-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"Partitioning library for fdisk-like programs.","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gzip","nvra":"gzip-1.10-9.el9_0.aarch64","release":"9.el9_0","srpm_name":"gzip","srpm_nevra":"gzip-0:1.10-9.el9_0.src","version":"1.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cracklib","nvra":"cracklib-2.9.6-27.el9.aarch64","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"A password-checking library","version":"2.9.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cracklib-dicts","nvra":"cracklib-dicts-2.9.6-27.el9.aarch64","release":"27.el9","srpm_name":"cracklib","srpm_nevra":"cracklib-0:2.9.6-27.el9.src","summary":"The standard CrackLib dictionaries","version":"2.9.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsemanage","nvra":"libsemanage-3.3-2.el9.aarch64","release":"2.el9","srpm_name":"libsemanage","srpm_nevra":"libsemanage-0:3.3-2.el9.src","summary":"SELinux binary policy manipulation library","version":"3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"shadow-utils","nvra":"shadow-utils-4.9-3.el9.aarch64","release":"3.el9","srpm_name":"shadow-utils","srpm_nevra":"shadow-utils-2:4.9-3.el9.src","summary":"Utilities for managing accounts and shadow password files","version":"4.9"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libutempter","nvra":"libutempter-1.2.1-6.el9.aarch64","release":"6.el9","srpm_name":"libutempter","srpm_nevra":"libutempter-0:1.2.1-6.el9.src","summary":"A privileged helper for utmp/wtmp updates","version":"1.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libidn2","nvra":"libidn2-2.3.0-7.el9.aarch64","release":"7.el9","srpm_name":"libidn2","srpm_nevra":"libidn2-0:2.3.0-7.el9.src","summary":"Library to support IDNA2008 internationalized domain names","version":"2.3.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"acl","nvra":"acl-2.3.1-3.el9.aarch64","release":"3.el9","srpm_name":"acl","srpm_nevra":"acl-0:2.3.1-3.el9.src","summary":"Access control list utilities","version":"2.3.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcomps","nvra":"libcomps-0.1.18-1.el9.aarch64","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Comps XML file manipulation library","version":"0.1.18"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"mpfr","nvra":"mpfr-4.1.0-7.el9.aarch64","release":"7.el9","srpm_name":"mpfr","srpm_nevra":"mpfr-0:4.1.0-7.el9.src","summary":"C library for multiple-precision floating-point computations","version":"4.1.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gawk","nvra":"gawk-5.1.0-6.el9.aarch64","release":"6.el9","srpm_name":"gawk","srpm_nevra":"gawk-0:5.1.0-6.el9.src","summary":"The GNU version of the AWK text processing utility","version":"5.1.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"nettle","nvra":"nettle-3.7.3-2.el9.aarch64","release":"2.el9","srpm_name":"nettle","srpm_nevra":"nettle-0:3.7.3-2.el9.src","summary":"A low-level cryptographic library","version":"3.7.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libksba","nvra":"libksba-1.5.1-4.el9.aarch64","release":"4.el9","srpm_name":"libksba","srpm_nevra":"libksba-0:1.5.1-4.el9.src","summary":"CMS and X.509 library","version":"1.5.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"systemd-rpm-macros","nvra":"systemd-rpm-macros-250-6.el9_0.noarch","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"Macros that define paths and scriptlets related to systemd","version":"250"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"alternatives","nvra":"alternatives-1.20-2.el9.aarch64","release":"2.el9","srpm_name":"chkconfig","srpm_nevra":"chkconfig-0:1.20-2.el9.src","summary":"A tool to maintain symbolic links determining default commands","version":"1.20"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"p11-kit-trust","nvra":"p11-kit-trust-0.24.1-2.el9.aarch64","release":"2.el9","srpm_name":"p11-kit","srpm_nevra":"p11-kit-0:0.24.1-2.el9.src","summary":"System trust module from p11-kit","version":"0.24.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"ca-certificates","nvra":"ca-certificates-2020.2.50-94.el9.noarch","release":"94.el9","srpm_name":"ca-certificates","srpm_nevra":"ca-certificates-0:2020.2.50-94.el9.src","summary":"The Mozilla CA root certificate bundle","version":"2020.2.50"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"openssl-libs","nvra":"openssl-libs-3.0.1-23.el9_0.aarch64","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"A general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd-libs","nvra":"systemd-libs-250-6.el9_0.aarch64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd libraries","version":"250"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gnutls","nvra":"gnutls-3.7.3-9.el9.aarch64","release":"9.el9","srpm_name":"gnutls","srpm_nevra":"gnutls-0:3.7.3-9.el9.src","summary":"A TLS protocol implementation","version":"3.7.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"glib2","nvra":"glib2-2.68.4-5.el9.aarch64","release":"5.el9","srpm_name":"glib2","srpm_nevra":"glib2-0:2.68.4-5.el9.src","summary":"A library of handy utility functions","version":"2.68.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gobject-introspection","nvra":"gobject-introspection-1.68.0-10.el9.aarch64","release":"10.el9","srpm_name":"gobject-introspection","srpm_nevra":"gobject-introspection-0:1.68.0-10.el9.src","summary":"Introspection system for GObject-based libraries","version":"1.68.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"json-glib","nvra":"json-glib-1.6.6-1.el9.aarch64","release":"1.el9","srpm_name":"json-glib","srpm_nevra":"json-glib-0:1.6.6-1.el9.src","summary":"Library for JavaScript Object Notation format","version":"1.6.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"librhsm","nvra":"librhsm-0.0.3-7.el9.aarch64","release":"7.el9","srpm_name":"librhsm","srpm_nevra":"librhsm-0:0.0.3-7.el9.src","summary":"Red Hat Subscription Manager library","version":"0.0.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-libs","nvra":"dbus-libs-1.12.20-5.el9.aarch64","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"Libraries for accessing D-BUS","version":"1.12.20"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"util-linux-core","nvra":"util-linux-core-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"The most essential utilities from the util-linux suite.","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"kmod-libs","nvra":"kmod-libs-28-7.el9.aarch64","release":"7.el9","srpm_name":"kmod","srpm_nevra":"kmod-0:28-7.el9.src","summary":"Libraries to handle kernel module loading and unloading","version":"28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libarchive","nvra":"libarchive-3.5.3-1.el9.aarch64","release":"1.el9","srpm_name":"libarchive","srpm_nevra":"libarchive-0:3.5.3-1.el9.src","summary":"A library for handling streaming archive formats","version":"3.5.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"openssl","nvra":"openssl-3.0.1-23.el9_0.aarch64","release":"23.el9_0","srpm_name":"openssl","srpm_nevra":"openssl-1:3.0.1-23.el9_0.src","summary":"Utilities from the general purpose cryptography library with TLS implementation","version":"3.0.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pip-wheel","nvra":"python3-pip-wheel-21.2.3-6.el9.noarch","release":"6.el9","srpm_name":"python-pip","srpm_nevra":"python-pip-0:21.2.3-6.el9.src","summary":"The pip wheel","version":"21.2.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3","nvra":"python3-3.9.10-2.el9.aarch64","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python 3.9 interpreter","version":"3.9.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libs","nvra":"python3-libs-3.9.10-2.el9.aarch64","release":"2.el9","srpm_name":"python3.9","srpm_nevra":"python3.9-0:3.9.10-2.el9.src","summary":"Python runtime libraries","version":"3.9.10"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-dbus","nvra":"python3-dbus-1.2.18-2.el9.aarch64","release":"2.el9","srpm_name":"dbus-python","srpm_nevra":"dbus-python-0:1.2.18-2.el9.src","summary":"D-Bus bindings for python3","version":"1.2.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-six","nvra":"python3-six-1.15.0-9.el9.noarch","release":"9.el9","srpm_name":"python-six","srpm_nevra":"python-six-0:1.15.0-9.el9.src","summary":"Python 2 and 3 compatibility utilities","version":"1.15.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dateutil","nvra":"python3-dateutil-2.8.1-6.el9.noarch","release":"6.el9","srpm_name":"python-dateutil","srpm_nevra":"python-dateutil-1:2.8.1-6.el9.src","summary":"Powerful extensions to the standard datetime module","version":"2.8.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-iniparse","nvra":"python3-iniparse-0.4-45.el9.noarch","release":"45.el9","srpm_name":"python-iniparse","srpm_nevra":"python-iniparse-0:0.4-45.el9.src","summary":"Python Module for Accessing and Modifying Configuration Data in INI files","version":"0.4"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-idna","nvra":"python3-idna-2.10-7.el9.noarch","release":"7.el9","srpm_name":"python-idna","srpm_nevra":"python-idna-0:2.10-7.el9.src","summary":"Internationalized Domain Names in Applications (IDNA)","version":"2.10"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-setuptools","nvra":"python3-setuptools-53.0.0-10.el9.noarch","release":"10.el9","srpm_name":"python-setuptools","srpm_nevra":"python-setuptools-0:53.0.0-10.el9.src","summary":"Easily build and distribute Python 3 packages","version":"53.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-inotify","nvra":"python3-inotify-0.9.6-25.el9.noarch","release":"25.el9","srpm_name":"python-inotify","srpm_nevra":"python-inotify-0:0.9.6-25.el9.src","summary":"Monitor filesystem events with Python under Linux","version":"0.9.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libcomps","nvra":"python3-libcomps-0.1.18-1.el9.aarch64","release":"1.el9","srpm_name":"libcomps","srpm_nevra":"libcomps-0:0.1.18-1.el9.src","summary":"Python 3 bindings for libcomps library","version":"0.1.18"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-chardet","nvra":"python3-chardet-4.0.0-5.el9.noarch","release":"5.el9","srpm_name":"python-chardet","srpm_nevra":"python-chardet-0:4.0.0-5.el9.src","summary":"Character encoding auto-detection in Python","version":"4.0.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-decorator","nvra":"python3-decorator-4.4.2-6.el9.noarch","release":"6.el9","srpm_name":"python-decorator","srpm_nevra":"python-decorator-0:4.4.2-6.el9.src","summary":"Module to simplify usage of decorators in python3","version":"4.4.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-gobject-base","nvra":"python3-gobject-base-3.40.1-5.el9.aarch64","release":"5.el9","srpm_name":"pygobject3","srpm_nevra":"pygobject3-0:3.40.1-5.el9.src","summary":"Python 3 bindings for GObject Introspection base package","version":"3.40.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-pysocks","nvra":"python3-pysocks-1.7.1-12.el9.noarch","release":"12.el9","srpm_name":"python-pysocks","srpm_nevra":"python-pysocks-0:1.7.1-12.el9.src","summary":"A Python SOCKS client module","version":"1.7.1"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-urllib3","nvra":"python3-urllib3-1.26.5-3.el9.noarch","release":"3.el9","srpm_name":"python-urllib3","srpm_nevra":"python-urllib3-0:1.26.5-3.el9.src","summary":"Python3 HTTP library with thread-safe connection pooling and file post","version":"1.26.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-requests","nvra":"python3-requests-2.25.1-6.el9.noarch","release":"6.el9","srpm_name":"python-requests","srpm_nevra":"python-requests-0:2.25.1-6.el9.src","summary":"HTTP library, written in Python, for human beings","version":"2.25.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-cloud-what","nvra":"python3-cloud-what-1.29.26-3.el9_0.aarch64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Python package for detection of public cloud provider","version":"1.29.26"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dmidecode","nvra":"dmidecode-3.3-7.el9.aarch64","release":"7.el9","srpm_name":"dmidecode","srpm_nevra":"dmidecode-1:3.3-7.el9.src","summary":"Tool to analyse BIOS DMI data","version":"3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdb","nvra":"libdb-5.3.28-53.el9.aarch64","release":"53.el9","srpm_name":"libdb","srpm_nevra":"libdb-0:5.3.28-53.el9.src","summary":"The Berkeley DB database library for C","version":"5.3.28"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libeconf","nvra":"libeconf-0.4.1-2.el9.aarch64","release":"2.el9","srpm_name":"libeconf","srpm_nevra":"libeconf-0:0.4.1-2.el9.src","summary":"Enhanced config file parser library","version":"0.4.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libpwquality","nvra":"libpwquality-1.4.4-8.el9.aarch64","release":"8.el9","srpm_name":"libpwquality","srpm_nevra":"libpwquality-0:1.4.4-8.el9.src","summary":"A library for password generation and password quality checking","version":"1.4.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"pam","nvra":"pam-1.5.1-9.el9.aarch64","release":"9.el9","srpm_name":"pam","srpm_nevra":"pam-0:1.5.1-9.el9.src","summary":"An extensible library which provides authentication for applications","version":"1.5.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"util-linux","nvra":"util-linux-2.37.4-3.el9.aarch64","release":"3.el9","srpm_name":"util-linux","srpm_nevra":"util-linux-0:2.37.4-3.el9.src","summary":"A collection of basic system utilities","version":"2.37.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libgomp","nvra":"libgomp-11.2.1-9.4.el9.aarch64","release":"9.4.el9","srpm_name":"gcc","srpm_nevra":"gcc-0:11.2.1-9.4.el9.src","summary":"GCC OpenMP v4.5 shared support library","version":"11.2.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libnghttp2","nvra":"libnghttp2-1.43.0-5.el9.aarch64","release":"5.el9","srpm_name":"nghttp2","srpm_nevra":"nghttp2-0:1.43.0-5.el9.src","summary":"A library implementing the HTTP/2 protocol","version":"1.43.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libnl3","nvra":"libnl3-3.5.0-10.el9.aarch64","release":"10.el9","srpm_name":"libnl3","srpm_nevra":"libnl3-0:3.5.0-10.el9.src","summary":"Convenience library for kernel netlink sockets","version":"3.5.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-ethtool","nvra":"python3-ethtool-0.15-2.el9.aarch64","release":"2.el9","srpm_name":"python-ethtool","srpm_nevra":"python-ethtool-0:0.15-2.el9.src","summary":"Python module to interface with ethtool","version":"0.15"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libseccomp","nvra":"libseccomp-2.5.2-2.el9.aarch64","release":"2.el9","srpm_name":"libseccomp","srpm_nevra":"libseccomp-0:2.5.2-2.el9.src","summary":"Enhanced seccomp library","version":"2.5.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"device-mapper","nvra":"device-mapper-1.02.183-4.el9.aarch64","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device mapper utility","version":"1.02.183"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"device-mapper-libs","nvra":"device-mapper-libs-1.02.183-4.el9.aarch64","release":"4.el9","srpm_name":"lvm2","srpm_nevra":"lvm2-9:2.03.14-4.el9.src","summary":"Device-mapper shared library","version":"1.02.183"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cryptsetup-libs","nvra":"cryptsetup-libs-2.4.3-4.el9.aarch64","release":"4.el9","srpm_name":"cryptsetup","srpm_nevra":"cryptsetup-0:2.4.3-4.el9.src","summary":"Cryptsetup shared library","version":"2.4.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus","nvra":"dbus-1.12.20-5.el9.aarch64","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus","version":"1.12.20"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd-pam","nvra":"systemd-pam-250-6.el9_0.aarch64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"systemd PAM module","version":"250"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"systemd","nvra":"systemd-250-6.el9_0.aarch64","release":"6.el9_0","srpm_name":"systemd","srpm_nevra":"systemd-0:250-6.el9_0.src","summary":"System and Service Manager","version":"250"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dbus-common","nvra":"dbus-common-1.12.20-5.el9.noarch","release":"5.el9","srpm_name":"dbus","srpm_nevra":"dbus-1:1.12.20-5.el9.src","summary":"D-BUS message bus configuration","version":"1.12.20"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"dbus-broker","nvra":"dbus-broker-28-5.el9.aarch64","release":"5.el9","srpm_name":"dbus-broker","srpm_nevra":"dbus-broker-0:28-5.el9.src","summary":"Linux D-Bus Message Broker","version":"28"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"elfutils-default-yama-scope","nvra":"elfutils-default-yama-scope-0.186-1.el9.noarch","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Default yama attach scope sysctl setting","version":"0.186"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"elfutils-libs","nvra":"elfutils-libs-0.186-1.el9.aarch64","release":"1.el9","srpm_name":"elfutils","srpm_nevra":"elfutils-0:0.186-1.el9.src","summary":"Libraries to handle compiled objects","version":"0.186"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libverto","nvra":"libverto-0.3.2-3.el9.aarch64","release":"3.el9","srpm_name":"libverto","srpm_nevra":"libverto-0:0.3.2-3.el9.src","summary":"Main loop abstraction library","version":"0.3.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"krb5-libs","nvra":"krb5-libs-1.19.1-15.el9_0.aarch64","release":"15.el9_0","srpm_name":"krb5","srpm_nevra":"krb5-0:1.19.1-15.el9_0.src","summary":"The non-admin shared libraries used by Kerberos 5","version":"1.19.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libcurl-minimal","nvra":"libcurl-minimal-7.76.1-14.el9.aarch64","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of libcurl for minimal installations","version":"7.76.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"curl-minimal","nvra":"curl-minimal-7.76.1-14.el9.aarch64","release":"14.el9","srpm_name":"curl","srpm_nevra":"curl-0:7.76.1-14.el9.src","summary":"Conservatively configured build of curl for minimal installations","version":"7.76.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm","nvra":"rpm-4.16.1.3-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"The RPM package management system","version":"4.16.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm-libs","nvra":"rpm-libs-4.16.1.3-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for manipulating RPM packages","version":"4.16.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libsolv","nvra":"libsolv-0.7.20-2.el9.aarch64","release":"2.el9","srpm_name":"libsolv","srpm_nevra":"libsolv-0:0.7.20-2.el9.src","summary":"Package dependency solver","version":"0.7.20"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm-build-libs","nvra":"rpm-build-libs-4.16.1.3-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for building RPM packages","version":"4.16.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"tpm2-tss","nvra":"tpm2-tss-3.0.3-7.el9.aarch64","release":"7.el9","srpm_name":"tpm2-tss","srpm_nevra":"tpm2-tss-0:3.0.3-7.el9.src","summary":"TPM2.0 Software Stack","version":"3.0.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"ima-evm-utils","nvra":"ima-evm-utils-1.4-4.el9.aarch64","release":"4.el9","srpm_name":"ima-evm-utils","srpm_nevra":"ima-evm-utils-0:1.4-4.el9.src","summary":"IMA/EVM support utilities","version":"1.4"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"cyrus-sasl-lib","nvra":"cyrus-sasl-lib-2.1.27-20.el9.aarch64","release":"20.el9","srpm_name":"cyrus-sasl","srpm_nevra":"cyrus-sasl-0:2.1.27-20.el9.src","summary":"Shared libraries needed by applications which use Cyrus SASL","version":"2.1.27"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"openldap","nvra":"openldap-2.4.59-4.el9_0.aarch64","release":"4.el9_0","srpm_name":"openldap","srpm_nevra":"openldap-0:2.4.59-4.el9_0.src","summary":"LDAP support libraries","version":"2.4.59"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libuser","nvra":"libuser-0.63-10.el9.aarch64","release":"10.el9","srpm_name":"libuser","srpm_nevra":"libuser-0:0.63-10.el9.src","summary":"A user and group account administration library","version":"0.63"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"passwd","nvra":"passwd-0.80-12.el9.aarch64","release":"12.el9","srpm_name":"passwd","srpm_nevra":"passwd-0:0.80-12.el9.src","summary":"An utility for setting or changing passwords using PAM","version":"0.80"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"usermode","nvra":"usermode-1.114-4.el9.aarch64","release":"4.el9","srpm_name":"usermode","srpm_nevra":"usermode-0:1.114-4.el9.src","summary":"Tools for certain user account management tasks","version":"1.114"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libyaml","nvra":"libyaml-0.2.5-7.el9.aarch64","release":"7.el9","srpm_name":"libyaml","srpm_nevra":"libyaml-0:0.2.5-7.el9.src","summary":"YAML 1.1 parser and emitter written in C","version":"0.2.5"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libmodulemd","nvra":"libmodulemd-2.13.0-2.el9.aarch64","release":"2.el9","srpm_name":"libmodulemd","srpm_nevra":"libmodulemd-0:2.13.0-2.el9.src","summary":"Module metadata manipulation library","version":"2.13.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"npth","nvra":"npth-1.6-8.el9.aarch64","release":"8.el9","srpm_name":"npth","srpm_nevra":"npth-0:1.6-8.el9.src","summary":"The New GNU Portable Threads library","version":"1.6"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gnupg2","nvra":"gnupg2-2.3.3-1.el9.aarch64","release":"1.el9","srpm_name":"gnupg2","srpm_nevra":"gnupg2-0:2.3.3-1.el9.src","summary":"Utility for secure communication and data storage","version":"2.3.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gpgme","nvra":"gpgme-1.15.1-6.el9.aarch64","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"GnuPG Made Easy - high level crypto API","version":"1.15.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"librepo","nvra":"librepo-1.14.2-1.el9.aarch64","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Repodata downloading library","version":"1.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdnf","nvra":"libdnf-0.65.0-5.el9_0.aarch64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Library providing simplified C and Python API to libsolv","version":"0.65.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-libdnf","nvra":"python3-libdnf-0.65.0-5.el9_0.aarch64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the libdnf library.","version":"0.65.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-hawkey","nvra":"python3-hawkey-0.65.0-5.el9_0.aarch64","release":"5.el9_0","srpm_name":"libdnf","srpm_nevra":"libdnf-0:0.65.0-5.el9_0.src","summary":"Python 3 bindings for the hawkey library","version":"0.65.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-librepo","nvra":"python3-librepo-1.14.2-1.el9.aarch64","release":"1.el9","srpm_name":"librepo","srpm_nevra":"librepo-0:1.14.2-1.el9.src","summary":"Python 3 bindings for the librepo library","version":"1.14.2"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-gpg","nvra":"python3-gpg-1.15.1-6.el9.aarch64","release":"6.el9","srpm_name":"gpgme","srpm_nevra":"gpgme-0:1.15.1-6.el9.src","summary":"gpgme bindings for Python 3","version":"1.15.1"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"rpm-sign-libs","nvra":"rpm-sign-libs-4.16.1.3-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Libraries for signing RPM packages","version":"4.16.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-rpm","nvra":"python3-rpm-4.16.1.3-12.el9_0.aarch64","release":"12.el9_0","srpm_name":"rpm","srpm_nevra":"rpm-0:4.16.1.3-12.el9_0.src","summary":"Python 3 bindings for apps which will manipulate RPM packages","version":"4.16.1.3"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"python3-subscription-manager-rhsm","nvra":"python3-subscription-manager-rhsm-1.29.26-3.el9_0.aarch64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"A Python library to communicate with a Red Hat Unified Entitlement Platform","version":"1.29.26"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"which","nvra":"which-2.21-27.el9.aarch64","release":"27.el9","srpm_name":"which","srpm_nevra":"which-0:2.21-27.el9.src","summary":"Displays where a particular program in your path is located","version":"2.21"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"virt-what","nvra":"virt-what-1.21-2.el9.2.aarch64","release":"2.el9.2","srpm_name":"virt-what","srpm_nevra":"virt-what-0:1.21-2.el9.2.src","summary":"Detect if we are running in a virtual machine","version":"1.21"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"libreport-filesystem","nvra":"libreport-filesystem-2.15.2-6.el9.noarch","release":"6.el9","srpm_name":"libreport","srpm_nevra":"libreport-0:2.15.2-6.el9.src","summary":"Filesystem layout for libreport","version":"2.15.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf-data","nvra":"dnf-data-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Common data and configuration files for DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf","nvra":"python3-dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Python 3 interface to DNF","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dnf","nvra":"dnf-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"libdnf-plugin-subscription-manager","nvra":"libdnf-plugin-subscription-manager-1.29.26-3.el9_0.aarch64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Subscription Manager plugin for libdnf","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"python3-dnf-plugins-core","nvra":"python3-dnf-plugins-core-4.0.24-4.el9_0.noarch","release":"4.el9_0","srpm_name":"dnf-plugins-core","srpm_nevra":"dnf-plugins-core-0:4.0.24-4.el9_0.src","summary":"Core Plugins for DNF","version":"4.0.24"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"fonts-filesystem","nvra":"fonts-filesystem-2.0.5-7.el9.1.noarch","release":"7.el9.1","srpm_name":"fonts-rpm-macros","srpm_nevra":"fonts-rpm-macros-1:2.0.5-7.el9.1.src","summary":"Directories used by font packages","version":"2.0.5"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"dejavu-sans-fonts","nvra":"dejavu-sans-fonts-2.37-18.el9.noarch","release":"18.el9","srpm_name":"dejavu-fonts","srpm_nevra":"dejavu-fonts-0:2.37-18.el9.src","summary":"DejaVu Sans, a variable-width sans-serif font family","version":"2.37"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-font-en","nvra":"langpacks-core-font-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English core font meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-core-en","nvra":"langpacks-core-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks core meta-package","version":"3.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"langpacks-en","nvra":"langpacks-en-3.0-16.el9.noarch","release":"16.el9","srpm_name":"langpacks","srpm_nevra":"langpacks-0:3.0-16.el9.src","summary":"English langpacks meta-package","version":"3.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"subscription-manager","nvra":"subscription-manager-1.29.26-3.el9_0.aarch64","release":"3.el9_0","srpm_name":"subscription-manager","srpm_nevra":"subscription-manager-0:1.29.26-3.el9_0.src","summary":"Tools and libraries for subscription and repository management","version":"1.29.26"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"yum","nvra":"yum-4.10.0-5.el9_0.noarch","release":"5.el9_0","srpm_name":"dnf","srpm_nevra":"dnf-0:4.10.0-5.el9_0.src","summary":"Package manager","version":"4.10.0"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"crypto-policies-scripts","nvra":"crypto-policies-scripts-20220223-1.git5203b41.el9_0.1.noarch","release":"1.git5203b41.el9_0.1","srpm_name":"crypto-policies","srpm_nevra":"crypto-policies-0:20220223-1.git5203b41.el9_0.1.src","summary":"Tool to switch between crypto policies","version":"20220223"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"findutils","nvra":"findutils-4.8.0-5.el9.aarch64","release":"5.el9","srpm_name":"findutils","srpm_nevra":"findutils-1:4.8.0-5.el9.src","summary":"The GNU versions of find utilities (find and xargs)","version":"4.8.0"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"tar","nvra":"tar-1.34-3.el9.aarch64","release":"3.el9","srpm_name":"tar","srpm_nevra":"tar-2:1.34-3.el9.src","summary":"GNU file archiving program","version":"1.34"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"vim-minimal","nvra":"vim-minimal-8.2.2637-15.el9.aarch64","release":"15.el9","srpm_name":"vim","srpm_nevra":"vim-2:8.2.2637-15.el9.src","summary":"A minimal version of the VIM editor","version":"8.2.2637"},{"architecture":"aarch64","gpg":"199e2f91fd431d51","name":"gdb-gdbserver","nvra":"gdb-gdbserver-10.2-9.el9.aarch64","release":"9.el9","srpm_name":"gdb","srpm_nevra":"gdb-0:10.2-9.el9.src","summary":"A standalone server for GDB (the GNU source-level debugger)","version":"10.2"},{"architecture":"noarch","gpg":"199e2f91fd431d51","name":"rootfiles","nvra":"rootfiles-8.1-31.el9.noarch","release":"31.el9","srpm_name":"rootfiles","srpm_nevra":"rootfiles-0:8.1-31.el9.src","summary":"The basic required files for the root user's directory","version":"8.1"}],"_links":{"image":{"href":"/v1/images/id/6270e10180cc9b3025076e97"}}} diff --git a/rpm/files.go b/rpm/files.go index 799de9d08..6e4efaa62 100644 --- a/rpm/files.go +++ b/rpm/files.go @@ -2,156 +2,15 @@ package rpm import ( "context" - "errors" - "fmt" - "io/fs" - "sync" - - "github.com/quay/zlog" - "golang.org/x/sync/singleflight" "github.com/quay/claircore" + "github.com/quay/claircore/internal/rpm" ) -// FilesCache is used for concurrent access to the map containing -// [claircore.Layer] -> map[string]struct{}. -type filesCache struct { - c map[string]map[string]struct{} - refs map[string]int - mu sync.Mutex - sf singleflight.Group - // wg tracks the gc calls made during get. This is particularly useful - // during testing, so we can wait on all the gc calls before asserting - // the cache is indeed empty and all the references were accounted for. - wg sync.WaitGroup -} - -var fc = &filesCache{ - c: map[string]map[string]struct{}{}, - refs: map[string]int{}, -} - -// GC decrements the reference counter and deletes the [claircore.Layer]'s -// entry from the cache map and the reference counter once the references -// are 0 (or less). -func (fc *filesCache) gc(key string) { - fc.mu.Lock() - defer fc.mu.Unlock() - fc.refs[key]-- - if fc.refs[key] <= 0 { - delete(fc.c, key) - delete(fc.refs, key) - fc.sf.Forget(key) - } -} - -// Get increments the reference counter for the key and looks up the key -// in the cache. It will subsequently start a goroutine to track when the -// calling context is done, calling the gc method. -func (fc *filesCache) get(ctx context.Context, key string) (map[string]struct{}, bool) { - fc.mu.Lock() - defer fc.mu.Unlock() - fc.refs[key]++ - f, ok := fc.c[key] - fc.wg.Add(1) - go func() { - defer fc.wg.Done() - <-ctx.Done() - fc.gc(key) - }() - return f, ok -} - -// Set sets the files for a particular key and deals with the locking. -func (fc *filesCache) set(key string, files map[string]struct{}) { - fc.mu.Lock() - defer fc.mu.Unlock() - fc.c[key] = files -} - -var errNoDBFound = errors.New("no RPM DB found") - -// GetFiles looks up RPM files that exist in the RPM database using the -// filesFromDB function and memoizes the result to avoid repeated work -// for the same [claircore.Layer]. -func (fc *filesCache) getFiles(ctx context.Context, layer *claircore.Layer) (map[string]struct{}, error) { - key := layer.Hash.String() - if files, ok := fc.get(ctx, key); ok { - return files, nil - } - - files := map[string]struct{}{} - ch := fc.sf.DoChan(key, func() (interface{}, error) { - sys, err := layer.FS() - if err != nil { - return nil, fmt.Errorf("rpm: unable to open layer: %w", err) - } - - found := make([]foundDB, 0) - if err := fs.WalkDir(sys, ".", findDBs(ctx, &found, sys)); err != nil { - return nil, fmt.Errorf("rpm: error walking fs: %w", err) - } - if len(found) == 0 { - return nil, errNoDBFound - } - - done := map[string]struct{}{} - zlog.Debug(ctx).Int("count", len(found)).Msg("found possible databases") - for _, db := range found { - ctx := zlog.ContextWithValues(ctx, "db", db.String()) - zlog.Debug(ctx).Msg("examining database") - if _, ok := done[db.Path]; ok { - zlog.Debug(ctx).Msg("already seen, skipping") - continue - } - done[db.Path] = struct{}{} - fs, err := getDBObjects(ctx, sys, db, filesFromDB) - if err != nil { - return nil, fmt.Errorf("rpm: error getting native DBs: %w", err) - } - for _, f := range fs { - files[f.Path] = struct{}{} - } - } - fc.set(key, files) - return files, nil - }) - select { - case <-ctx.Done(): - return nil, context.Cause(ctx) - case res := <-ch: - switch { - case res.Err == nil: - files = res.Val.(map[string]struct{}) - case errors.Is(res.Err, errNoDBFound): - default: - return nil, res.Err - } - } - - return files, nil -} - -// NewFileChecker creates a new FileChecker using the file cache to memoize lookups -// of the set of paths that are RPM files. -func NewFileChecker(ctx context.Context, layer *claircore.Layer) (*FileChecker, error) { - fs, err := fc.getFiles(ctx, layer) - if err != nil { - return nil, err - } - return &FileChecker{ - files: fs, - }, nil -} - -// FileChecker is used to check if a path is an RPM file. -type FileChecker struct { - files map[string]struct{} -} +// PathSet is a set of paths "owned" by rpm packages in a given layer. +type PathSet = rpm.PathSet -// IsRPM returns true if the given path exists in the set of paths that are -// considered to be RPM files in the layer this FileChecker was created for. -func (fc *FileChecker) IsRPM(path string) bool { - _, exists := fc.files[path] - return exists +// NewPathSet returns a [PathSet] for the provided layer. +func NewPathSet(ctx context.Context, layer *claircore.Layer) (*PathSet, error) { + return rpm.NewPathSet(ctx, layer) } diff --git a/rpm/files_test.go b/rpm/files_test.go deleted file mode 100644 index 65cca9f96..000000000 --- a/rpm/files_test.go +++ /dev/null @@ -1,108 +0,0 @@ -package rpm - -import ( - "context" - "fmt" - "testing" - - "github.com/quay/zlog" - - "github.com/quay/claircore" - "github.com/quay/claircore/test" -) - -var ( - cache = map[string]map[string]struct{}{} - refs = map[string]int{} - - testFileCache = &filesCache{ - c: cache, - refs: refs, - } -) - -var rpmFilesTestcases = []struct { - name string - isRPM bool - filePath string -}{ - { - name: "Found Node", - isRPM: true, - filePath: "usr/lib/node_modules/npm/node_modules/safe-buffer/package.json", - }, - { - name: "Found Python", - isRPM: true, - filePath: "usr/lib64/python3.9/site-packages/libcomps-0.1.18-py3.9.egg-info/PKG-INFO", - }, - { - name: "Not found", - isRPM: false, - filePath: "usr/lib/node_modules/npm/node_modules/safe-buffer/package.jsonx", - }, -} - -func TestIsRPMFile(t *testing.T) { - ctx := zlog.Test(context.Background(), t) - a := test.NewCachedArena(t) - fc = testFileCache - layer := test.LayerRef{ - Registry: "registry.access.redhat.com", - Name: "ubi9/nodejs-18", - Digest: `sha256:1ae06b64755052cef4c32979aded82a18f664c66fa7b50a6d2924afac2849c6e`, - } - a.LoadLayerFromRegistry(ctx, t, layer) - r := a.Realizer(ctx).(*test.CachedRealizer) - t.Cleanup(func() { - if err := r.Close(); err != nil { - t.Error(err) - } - }) - t.Cleanup(func() { - fc.wg.Wait() // Wait for all goroutines to finish - err := checkCleanup(fc) - if err != nil { - t.Error(err) - } - }) - - realizedLayers, err := r.RealizeDescriptions(ctx, []claircore.LayerDescription{ - { - Digest: layer.Digest, - URI: "http://example.com", - MediaType: test.MediaType, - Headers: make(map[string][]string), - }, - }) - if err != nil { - t.Fatal(err) - } - for _, tt := range rpmFilesTestcases { - t.Run(tt.name, func(t *testing.T) { - ctx, cancel := context.WithCancel(zlog.Test(context.Background(), t)) - t.Parallel() - fc, err := NewFileChecker(ctx, &realizedLayers[0]) - if err != nil { - t.Fatal(err) - } - isRPM := fc.IsRPM(tt.filePath) - if tt.isRPM != isRPM { - t.Errorf("expected isRPM: %t, got isRPM: %t", tt.isRPM, isRPM) - } - cancel() - }) - } -} - -func checkCleanup(fc *filesCache) error { - fc.mu.Lock() - defer fc.mu.Unlock() - if len(cache) > 0 { - return fmt.Errorf("cache is left unclean after a second: %d items left", len(cache)) - } - if len(refs) > 0 { - return fmt.Errorf("refs left unclean after a second: %d items left", len(refs)) - } - return nil -} diff --git a/rpm/internal/rpm/doc.go b/rpm/internal/rpm/doc.go deleted file mode 100644 index 20b453618..000000000 --- a/rpm/internal/rpm/doc.go +++ /dev/null @@ -1,6 +0,0 @@ -// Package rpm contains some internal helpers for working with RPM -// databases. -// -// The actual data stored in various databases is independent of the disk -// format, once extracted. -package rpm diff --git a/rpm/native_db.go b/rpm/native_db.go deleted file mode 100644 index 6d0578577..000000000 --- a/rpm/native_db.go +++ /dev/null @@ -1,533 +0,0 @@ -package rpm - -import ( - "bytes" - "context" - "errors" - "fmt" - "io" - "io/fs" - "net/url" - "os" - "path" - "regexp" - "runtime/trace" - "strings" - - "github.com/quay/zlog" - "golang.org/x/crypto/openpgp/packet" - - "github.com/quay/claircore" - "github.com/quay/claircore/rpm/bdb" - "github.com/quay/claircore/rpm/internal/rpm" - "github.com/quay/claircore/rpm/ndb" - "github.com/quay/claircore/rpm/sqlite" -) - -// NativeDB is the interface implemented for in-process RPM database handlers. -type nativeDB interface { - AllHeaders(context.Context) ([]io.ReaderAt, error) - Validate(context.Context) error -} - -// ObjectResponse is a generic object that we're expecting to extract from -// RPM database, currently either a slice of Packages or Files. -type ObjectResponse interface { - []*claircore.Package | []claircore.File -} - -// GetDBObjects does all the dirty work of extracting generic claircore objects -// from an RPM database. Provide it with a foundDB, the sys and a fn extract function -// it will create an implementation agnostic nativeDB and extract specific claircore -// objects from it. -func getDBObjects[T ObjectResponse](ctx context.Context, sys fs.FS, db foundDB, fn func(context.Context, string, nativeDB) (T, error)) (T, error) { - var nat nativeDB - switch db.Kind { - case kindSQLite: - r, err := sys.Open(path.Join(db.Path, `rpmdb.sqlite`)) - switch { - case errors.Is(err, nil): - case errors.Is(err, fs.ErrNotExist): - zlog.Warn(ctx).Err(err).Msg("rpm: unable to open sqlite db") - return nil, nil - default: - return nil, fmt.Errorf("rpm: unable to open sqlite db: %w", err) - } - defer func() { - if err := r.Close(); err != nil { - zlog.Warn(ctx).Err(err).Msg("unable to close sqlite db") - } - }() - f, err := os.CreateTemp(os.TempDir(), `rpmdb.sqlite.*`) - if err != nil { - return nil, fmt.Errorf("rpm: error reading sqlite db: %w", err) - } - defer func() { - if err := os.Remove(f.Name()); err != nil { - zlog.Error(ctx).Err(err).Msg("unable to unlink sqlite db") - } - if err := f.Close(); err != nil { - zlog.Warn(ctx).Err(err).Msg("unable to close sqlite db") - } - }() - zlog.Debug(ctx).Str("file", f.Name()).Msg("copying sqlite db out of FS") - if _, err := io.Copy(f, r); err != nil { - return nil, fmt.Errorf("rpm: error reading sqlite db: %w", err) - } - if err := f.Sync(); err != nil { - return nil, fmt.Errorf("rpm: error reading sqlite db: %w", err) - } - sdb, err := sqlite.Open(f.Name()) - if err != nil { - return nil, fmt.Errorf("rpm: error reading sqlite db: %w", err) - } - defer sdb.Close() - nat = sdb - case kindBDB: - f, err := sys.Open(path.Join(db.Path, `Packages`)) - if err != nil { - return nil, fmt.Errorf("rpm: error reading bdb db: %w", err) - } - defer f.Close() - r, done, err := mkAt(ctx, db.Kind, f) - if err != nil { - return nil, fmt.Errorf("rpm: error reading bdb db: %w", err) - } - defer done() - var bpdb bdb.PackageDB - if err := bpdb.Parse(r); err != nil { - return nil, fmt.Errorf("rpm: error parsing bdb db: %w", err) - } - nat = &bpdb - case kindNDB: - f, err := sys.Open(path.Join(db.Path, `Packages.db`)) - if err != nil { - return nil, fmt.Errorf("rpm: error reading ndb db: %w", err) - } - defer f.Close() - r, done, err := mkAt(ctx, db.Kind, f) - if err != nil { - return nil, fmt.Errorf("rpm: error reading ndb db: %w", err) - } - defer done() - var npdb ndb.PackageDB - if err := npdb.Parse(r); err != nil { - return nil, fmt.Errorf("rpm: error parsing ndb db: %w", err) - } - nat = &npdb - default: - panic("programmer error: bad kind: " + db.Kind.String()) - } - if err := nat.Validate(ctx); err != nil { - zlog.Warn(ctx). - Err(err). - Msg("rpm: invalid native DB") - return nil, nil - } - ps, err := fn(ctx, db.String(), nat) - if err != nil { - return nil, fmt.Errorf("rpm: error reading native db: %w", err) - } - - return ps, nil -} - -// FilesFromDB extracts the files that were instsalled via RPM from the -// RPM headers. -func filesFromDB(ctx context.Context, _ string, db nativeDB) ([]claircore.File, error) { - defer trace.StartRegion(ctx, "filesFromDB").End() - rds, err := db.AllHeaders(ctx) - if err != nil { - return nil, fmt.Errorf("rpm: error reading headers: %w", err) - } - var files []claircore.File - for _, rd := range rds { - var h rpm.Header - if err := h.Parse(ctx, rd); err != nil { - return nil, err - } - var info Info - if err := info.Load(ctx, &h); err != nil { - return nil, err - } - for _, f := range info.Filenames { - files = append(files, claircore.File{ - Path: f, - }) - } - } - return files, nil -} - -// PackagesFromDB extracts the packages from the RPM headers provided by -// the database. -func packagesFromDB(ctx context.Context, pkgdb string, db nativeDB) ([]*claircore.Package, error) { - defer trace.StartRegion(ctx, "packagesFromDB").End() - rds, err := db.AllHeaders(ctx) - if err != nil { - return nil, fmt.Errorf("rpm: error reading headers: %w", err) - } - // Bulk allocations: - ps := make([]claircore.Package, 0, len(rds)) - pkgs := make([]*claircore.Package, 0, len(rds)) - srcs := make([]claircore.Package, 0, len(rds)) // Worst-case size. - src := make(map[string]*claircore.Package) - src["(none)"] = nil - var b strings.Builder - - for _, rd := range rds { - var h rpm.Header - if err := h.Parse(ctx, rd); err != nil { - return nil, err - } - var info Info - if err := info.Load(ctx, &h); err != nil { - return nil, err - } - if info.Name == "gpg-pubkey" { - // This is *not* an rpm package. It is just a public key stored in the rpm database. - // Ignore this "package". - continue - } - - idx := len(ps) - ps = append(ps, claircore.Package{ - Kind: claircore.BINARY, - Name: info.Name, - Arch: info.Arch, - PackageDB: pkgdb, - }) - p := &ps[idx] - var modStream string - if strings.Count(info.Module, ":") > 1 { - first := true - idx := strings.IndexFunc(info.Module, func(r rune) bool { - if r != ':' { - return false - } - if first { - first = false - return false - } - return true - }) - modStream = info.Module[:idx] - } - p.Module = modStream - p.Version = constructEVR(&b, &info) - p.RepositoryHint = constructHint(&b, &info) - - if s, ok := src[info.SourceNEVR]; ok { - p.Source = s - } else { - s := strings.TrimSuffix(info.SourceNEVR, ".src.rpm") - pos := len(s) - for i := 0; i < 2; i++ { - pos = strings.LastIndexByte(s[:pos], '-') - if pos == -1 { - return nil, fmt.Errorf("malformed NEVR: %q", info.SourceNEVR) - } - } - - idx := len(srcs) - srcs = append(srcs, claircore.Package{ - Kind: claircore.SOURCE, - Name: s[:pos], - Version: strings.TrimPrefix(s[pos+1:], "0:"), - }) - pkg := &srcs[idx] - src[info.SourceNEVR] = pkg - p.Source = pkg - pkg.Module = modStream - } - - pkgs = append(pkgs, p) - } - zlog.Debug(ctx). - Int("packages", len(pkgs)). - Int("sources", len(srcs)). - Msg("processed rpm db") - return pkgs, nil -} - -// Info is the package information extracted from the RPM header. -type Info struct { - Name string - Version string - Release string - SourceNEVR string - Module string - Arch string - Digest string - Signature []byte // This is a PGP signature packet. - Filenames []string // Filtered by the [filePatterns] regexp. - DigestAlgo int - Epoch int -} - -// Load populates the receiver with information extracted from the provided -// [rpm.Header]. -func (i *Info) Load(ctx context.Context, h *rpm.Header) error { - var dirname, basename []string - var dirindex []int32 - for idx := range h.Infos { - e := &h.Infos[idx] - if _, ok := wantTags[e.Tag]; !ok { - continue - } - v, err := h.ReadData(ctx, e) - if err != nil { - return err - } - switch e.Tag { - case rpm.TagName: - i.Name = v.(string) - case rpm.TagEpoch: - i.Epoch = int(v.([]int32)[0]) - case rpm.TagVersion: - i.Version = v.(string) - case rpm.TagRelease: - i.Release = v.(string) - case rpm.TagSourceRPM: - i.SourceNEVR = v.(string) - case rpm.TagModularityLabel: - i.Module = v.(string) - case rpm.TagArch: - i.Arch = v.(string) - case rpm.TagPayloadDigestAlgo: - i.DigestAlgo = int(v.([]int32)[0]) - case rpm.TagPayloadDigest: - i.Digest = v.([]string)[0] - case rpm.TagSigPGP: - i.Signature = v.([]byte) - case rpm.TagDirnames: - dirname = v.([]string) - case rpm.TagDirindexes: - dirindex = v.([]int32) - case rpm.TagBasenames: - basename = v.([]string) - case rpm.TagFilenames: - // Filenames is the tag used in rpm4 -- this is a best-effort for - // supporting it. - for _, name := range v.([]string) { - if !filePatterns.MatchString(name) { - // Record the name as a relative path, as that's what we use - // everywhere else. - i.Filenames = append(i.Filenames, name[1:]) - } - } - } - } - - // Catch panics from malformed headers. Can't think of a better way to - // handle this. - defer func() { - if r := recover(); r == nil { - return - } - zlog.Warn(ctx). - Str("name", i.Name). - Strs("basename", basename). - Strs("dirname", dirname). - Ints32("dirindex", dirindex). - Msg("caught panic in filename construction") - i.Filenames = nil - }() - for j := range basename { - // We only want '/'-separated paths, even if running on some other, - // weird OS. It seems that RPM assumes '/' throughout. - name := path.Join(dirname[dirindex[j]], basename[j]) - if filePatterns.MatchString(name) { - // Record the name as a relative path, as that's what we use - // everywhere else. - i.Filenames = append(i.Filenames, name[1:]) - } - } - return nil -} - -// FilePatterns is a regular expression for *any* file that may need to be -// recorded alongside a package. -// -// The tested strings are absolute paths. -var filePatterns *regexp.Regexp - -func init() { - // TODO(hank) The blanket binary pattern is too broad and can miss things. - // Long-term, we should add pattern matching akin to [yara] or file(1) as a - // plugin mechanism that all indexers can use. That way, the Go indexer - // could register a pattern and use a shared filter over the - // [fs.WalkDirFunc] while this package (and dpkg, etc) can tell that another - // indexer will find those files relevant. - // - // [yara]: https://github.com/VirusTotal/yara - pat := []string{ - `^.*/[^/]+\.jar$`, // Jar files - `^.*/site-packages/[^/]+\.egg-info/PKG-INFO$`, // Python packages - `^.*/package.json$`, // npm packages - `^.*/[^/]+\.gemspec$`, // ruby gems - `^/usr/s?bin/[^/]+$`, // any executable - "^/usr/libexec/[^/]+/[^/]+$", // sometimes the executables are here too - } - filePatterns = regexp.MustCompile(strings.Join(pat, `|`)) -} - -var wantTags = map[rpm.Tag]struct{}{ - rpm.TagArch: {}, - rpm.TagBasenames: {}, - rpm.TagDirindexes: {}, - rpm.TagDirnames: {}, - rpm.TagEpoch: {}, - rpm.TagFilenames: {}, - rpm.TagModularityLabel: {}, - rpm.TagName: {}, - rpm.TagPayloadDigest: {}, - rpm.TagPayloadDigestAlgo: {}, - rpm.TagRelease: {}, - rpm.TagSigPGP: {}, - rpm.TagSourceRPM: {}, - rpm.TagVersion: {}, -} - -func constructEVR(b *strings.Builder, info *Info) string { - b.Reset() - if info.Epoch != 0 { - fmt.Fprintf(b, "%d:", info.Epoch) - } - b.WriteString(info.Version) - b.WriteByte('-') - b.WriteString(info.Release) - return b.String() -} - -func constructHint(_ *strings.Builder, info *Info) string { - v := url.Values{} - if info.Digest != "" { - switch info.DigestAlgo { - case 8: - v.Set("hash", "sha256:"+info.Digest) - } - } - if len(info.Signature) != 0 { - prd := packet.NewReader(bytes.NewReader(info.Signature)) - p, err := prd.Next() - for ; err == nil; p, err = prd.Next() { - switch p := p.(type) { - case *packet.SignatureV3: - if p.SigType != 0 { - continue - } - v.Set("key", fmt.Sprintf("%016x", p.IssuerKeyId)) - case *packet.Signature: - if p.SigType != 0 || p.IssuerKeyId == nil { - continue - } - v.Set("key", fmt.Sprintf("%016x", *p.IssuerKeyId)) - } - } - } - return v.Encode() -} - -func findDBs(ctx context.Context, out *[]foundDB, sys fs.FS) fs.WalkDirFunc { - return func(p string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - if d.IsDir() { - return nil - } - - dir, n := path.Split(p) - dir = path.Clean(dir) - switch n { - case `Packages`: - f, err := sys.Open(p) - if err != nil { - return err - } - ok := bdb.CheckMagic(ctx, f) - f.Close() - if !ok { - return nil - } - *out = append(*out, foundDB{ - Path: dir, - Kind: kindBDB, - }) - case `rpmdb.sqlite`: - *out = append(*out, foundDB{ - Path: dir, - Kind: kindSQLite, - }) - case `Packages.db`: - f, err := sys.Open(p) - if err != nil { - return err - } - ok := ndb.CheckMagic(ctx, f) - f.Close() - if !ok { - return nil - } - *out = append(*out, foundDB{ - Path: dir, - Kind: kindNDB, - }) - } - return nil - } -} - -func mkAt(ctx context.Context, k dbKind, f fs.File) (io.ReaderAt, func(), error) { - if r, ok := f.(io.ReaderAt); ok { - return r, func() {}, nil - } - spool, err := os.CreateTemp(os.TempDir(), `Packages.`+k.String()+`.`) - if err != nil { - return nil, nil, fmt.Errorf("rpm: error spooling db: %w", err) - } - ctx = zlog.ContextWithValues(ctx, "file", spool.Name()) - if err := os.Remove(spool.Name()); err != nil { - zlog.Error(ctx).Err(err).Msg("unable to remove spool; file leaked!") - } - zlog.Debug(ctx). - Msg("copying db out of fs.FS") - if _, err := io.Copy(spool, f); err != nil { - if err := spool.Close(); err != nil { - zlog.Warn(ctx).Err(err).Msg("unable to close spool") - } - return nil, nil, fmt.Errorf("rpm: error spooling db: %w", err) - } - return spool, closeSpool(ctx, spool), nil -} - -func closeSpool(ctx context.Context, f *os.File) func() { - return func() { - if err := f.Close(); err != nil { - zlog.Warn(ctx).Err(err).Msg("unable to close spool") - } - } -} - -type dbKind uint - -//go:generate -command stringer go run golang.org/x/tools/cmd/stringer -//go:generate stringer -linecomment -type dbKind - -const ( - _ dbKind = iota - - kindBDB // bdb - kindSQLite // sqlite - kindNDB // ndb -) - -type foundDB struct { - Path string - Kind dbKind -} - -func (f foundDB) String() string { - return f.Kind.String() + ":" + f.Path -} diff --git a/rpm/native_db_test.go b/rpm/native_db_test.go deleted file mode 100644 index 2a6b48d89..000000000 --- a/rpm/native_db_test.go +++ /dev/null @@ -1,144 +0,0 @@ -package rpm - -import ( - "context" - "encoding/json" - "errors" - "io" - "os" - "path/filepath" - "strings" - "testing" - - "github.com/google/go-cmp/cmp" - "github.com/quay/zlog" - "golang.org/x/tools/txtar" - - "github.com/quay/claircore/rpm/bdb" - "github.com/quay/claircore/rpm/internal/rpm" - "github.com/quay/claircore/rpm/ndb" - "github.com/quay/claircore/rpm/sqlite" -) - -func TestInfo(t *testing.T) { - t.Run("Files", func(t *testing.T) { - ms, err := filepath.Glob("testdata/Info.Files.*.txtar") - if err != nil { - t.Fatal(err) - } - for _, m := range ms { - ar, err := txtar.ParseFile(m) - if err != nil { - t.Fatal(err) - } - name := strings.TrimPrefix(strings.TrimSuffix(filepath.Base(m), ".txtar"), "Info.Files.") - t.Run(name, func(t *testing.T) { - t.Parallel() - ctx := zlog.Test(context.Background(), t) - filename := strings.TrimSpace(string(ar.Comment)) - t.Logf("opening %q", filename) - - var want map[string][]string - for _, f := range ar.Files { - if f.Name == "want.json" { - want = make(map[string][]string) - if err := json.Unmarshal(f.Data, &want); err != nil { - t.Fatal(err) - } - break - } - } - if want == nil { - t.Fatal(`"want.json" not found`) - } - - pre, _, ok := strings.Cut(filename, `/testdata/`) - if !ok { - t.Fatal("input file not in a testdata directory") - } - - var nat nativeDB - switch pre { - case `bdb`: - f, err := os.Open(filename) - if err != nil { - t.Fatal(err) - } else { - t.Cleanup(func() { f.Close() }) - } - var db bdb.PackageDB - if err := db.Parse(f); err != nil { - t.Fatal(err) - } - nat = &db - case `ndb`: - f, err := os.Open(filename) - if err != nil { - t.Fatal(err) - } else { - t.Cleanup(func() { f.Close() }) - } - var db ndb.PackageDB - if err := db.Parse(f); err != nil { - t.Fatal(err) - } - nat = &db - case `sqlite`: - f, err := os.Create(filepath.Join(t.TempDir(), "db")) - if err != nil { - t.Fatal(err) - } - src, err := os.Open(filename) - if err != nil { - t.Fatal(err) - } - if _, err := io.Copy(f, src); err != nil { - t.Fatal(err) - } - if err := errors.Join(src.Close(), f.Close()); err != nil { - t.Fatal(err) - } - filename = f.Name() - t.Logf("copied sqlite database to: %s", filename) - - db, err := sqlite.Open(filename) - if err != nil { - t.Fatal(err) - } else { - t.Cleanup(func() { db.Close() }) - } - nat = db - } - - rds, err := nat.AllHeaders(ctx) - if err != nil { - t.Fatal(err) - } - - got := make(map[string][]string, len(want)) - for _, rd := range rds { - var h rpm.Header - if err := h.Parse(ctx, rd); err != nil { - t.Error(err) - continue - } - var info Info - if err := info.Load(ctx, &h); err != nil { - t.Error(err) - continue - } - if info.Name == "gpg-pubkey" { - // This is *not* an rpm package. It is just a public key stored in the rpm database. - // Ignore this "package". - continue - } - got[info.Name] = info.Filenames - } - - if !cmp.Equal(got, want) { - t.Error(cmp.Diff(got, want)) - } - }) - } - }) -} diff --git a/rpm/ndb/index.go b/rpm/ndb/index.go deleted file mode 100644 index fe77ab5d1..000000000 --- a/rpm/ndb/index.go +++ /dev/null @@ -1,215 +0,0 @@ -package ndb - -import ( - "bytes" - "errors" - "fmt" - "io" -) - -// Index is an index over an RPM tag. -type Index struct { - // SlotSpace reads the slot section of the Index. - slotSpace *io.SectionReader - // KeySpace reads the key section of the Index. - keySpace *io.SectionReader - // HMask is the mask for hash keys. - hMask uint32 - - indexHeader -} - -// IndexHeader is the header for a tag index. It's meant to be embedded. -type indexHeader struct { - Generation uint32 - NSlots uint32 - UsedSlots uint32 - DummySlots uint32 - XMask uint32 - KeyEnd uint32 - KeyExcess uint32 -} - -// UnmarshalBinary implements encoding.BinaryUnmarshaler for an Index header. -func (i *indexHeader) UnmarshalBinary(b []byte) error { - const ( - magic = ('R' | 'p'<<8 | 'm'<<16 | 'I'<<24) - version = 0 - - offsetMagic = 0 - offsetVersion = 4 - offsetGeneration = 8 - offsetNSlots = 12 - offsetUsedSlots = 16 - offsetDummySlots = 20 - offsetXMask = 24 - offsetKeyEnd = 28 - offsetKeyExcess = 32 - offsetObsolete = 36 - ) - if len(b) < 64 { - return io.ErrShortBuffer - } - if le.Uint32(b[offsetMagic:]) != magic { - return errors.New("ndb: index: bad magic") - } - if le.Uint32(b[offsetVersion:]) != version { - return errors.New("ndb: index: bad version") - } - i.Generation = le.Uint32(b[offsetGeneration:]) - i.NSlots = le.Uint32(b[offsetNSlots:]) - i.UsedSlots = le.Uint32(b[offsetUsedSlots:]) - i.DummySlots = le.Uint32(b[offsetDummySlots:]) - i.XMask = le.Uint32(b[offsetXMask:]) - i.KeyEnd = le.Uint32(b[offsetKeyEnd:]) - i.KeyExcess = le.Uint32(b[offsetKeyExcess:]) - // 4 bytes "obsolete" - // 24 bytes padding - return nil -} - -// IndexPair is the package index and data offset. -type IndexPair struct { - Package uint32 - Data uint32 -} - -// Lookup returns the pair (if any) for the provided key. -func (i *Index) Lookup(s string) (pg []IndexPair, err error) { - // NOTE(hank) This is a pretty straight forward port of the C version. - const ( - slotSize = 8 - skip = ^uint32(0) - - offsetKey = 0 - offsetOffset = 4 - ) - var keyoff, x uint32 - keyh := murmur(s) - b := make([]byte, slotSize) -Look: - for h, hh := keyh&i.hMask, uint32(7); ; h, hh = (h+hh)&i.hMask, hh+1 { - off := int64(8 * h) - if _, err := i.slotSpace.ReadAt(b, off); err != nil { - return pg, fmt.Errorf("ndb: index: failed to read slot@0x%08x: %w", off, err) - } - x = le.Uint32(b) - switch { - case x == 0: - break Look - case x == skip: - continue - } - if keyoff == 0 { - switch { - case ((x ^ keyh) & i.XMask) != 0: - continue - case !i.equalkey(x & ^i.XMask, s): - continue - } - keyoff = x - } - if keyoff != x { - continue - } - data := le.Uint32(b[offsetOffset:]) - var ovldata uint32 - // If flagged for overflow, read the overflow segment: - if data&0x80000000 != 0 { - off += 4 * int64(h) - if _, err := i.slotSpace.ReadAt(b[:4], off); err != nil { - return pg, fmt.Errorf("ndb: index: failed to read overflow slot@0x%08x: %w", off, err) - } - ovldata = le.Uint32(b) - } - pg = append(pg, i.decodeData(data, ovldata)) - } - return pg, nil -} - -func (i *Index) equalkey(keyoff uint32, s string) bool { - if int64(keyoff)+int64(len(s))+1 > i.keySpace.Size() { - return false - } - l := len(s) - var b []byte - switch { - case l < 255: - b = make([]byte, 1+l) - case l < 65535: - b = make([]byte, 3+l) - default: - b = make([]byte, 7+l) - } - n, _ := i.keySpace.ReadAt(b, int64(keyoff)) - b = b[:n] - switch { - case l < 255: - if b[0] != uint8(l) { - return false - } - b = b[1:] - case l < 65535: - if b[0] != 255 || le.Uint16(b[:1]) != uint16(l) { - return false - } - b = b[3:] - default: - if b[0] != 255 || b[1] != 255 || b[2] != 255 || le.Uint32(b[3:]) != uint32(l) { - return false - } - b = b[7:] - } - return bytes.Equal([]byte(s), b) -} - -func (i *Index) decodeData(data, ovldata uint32) (t IndexPair) { - switch { - case (data & 0x80000000) != 0: - t.Data = data ^ 0x80000000 - t.Package = ovldata - case (data & 0x40000000) != 0: - t.Data = (data ^ 0x40000000) >> 24 - t.Package = data & 0xffffff - default: - t.Data = data >> 20 - t.Package = data & 0xfffff - } - return t -} - -func (i *Index) encodeData(pkgIdx, datIdx uint32) (data, ovldata uint32) { - switch { - case (pkgIdx < 0x100000 && datIdx < 0x400): - ovldata = 0 - data = pkgIdx | datIdx<<20 - case (pkgIdx < 0x1000000 && datIdx < 0x40): - ovldata = 0 - data = pkgIdx | datIdx<<24 | 0x40000000 - default: - ovldata = pkgIdx - data = datIdx | 0x80000000 - } - return data, ovldata -} - -// Parse closes over the provided [io.ReaderAt] and populates the provided Index. -func (i *Index) Parse(r io.ReaderAt) error { - const ( - indexSlotOffset = 64 - indexKeyChunksize = 4096 - ) - b := make([]byte, indexSlotOffset) - if _, err := r.ReadAt(b, 0); err != nil { - return fmt.Errorf("ndb: index: unable to read bytes: %w", err) - } - if err := i.indexHeader.UnmarshalBinary(b); err != nil { - return fmt.Errorf("ndb: index: unable to unmarshal header: %w", err) - } - - i.hMask = i.NSlots - 1 - i.slotSpace = io.NewSectionReader(r, indexSlotOffset, int64(i.NSlots)*12) - i.keySpace = io.NewSectionReader(r, indexSlotOffset+(int64(i.NSlots)*12), int64(i.KeyEnd)) - - return nil -} diff --git a/rpm/ndb/index_test.go b/rpm/ndb/index_test.go deleted file mode 100644 index 863b5f7d0..000000000 --- a/rpm/ndb/index_test.go +++ /dev/null @@ -1,32 +0,0 @@ -package ndb - -import ( - "os" - "testing" - - "github.com/quay/claircore/rpm/internal/rpm" -) - -func TestLoadIndex(t *testing.T) { - idxf, err := os.Open("testdata/Index.db") - if err != nil { - t.Fatal(err) - } - defer idxf.Close() - var xdb XDB - if err := xdb.Parse(idxf); err != nil { - t.Fatal(err) - } - idx, err := xdb.Index(rpm.TagName) - if err != nil { - t.Fatal(err) - } - p, err := idx.Lookup("filesystem") - if err != nil { - t.Fatal(err) - } - t.Logf("%+#v", p) - if p[0].Package != 3 { - t.Fail() - } -} diff --git a/rpm/ndb/ndb.go b/rpm/ndb/ndb.go deleted file mode 100644 index 207b4f8a2..000000000 --- a/rpm/ndb/ndb.go +++ /dev/null @@ -1,164 +0,0 @@ -package ndb - -import ( - "context" - "encoding/binary" - "errors" - "fmt" - "io" - - "github.com/quay/claircore/rpm/internal/rpm" -) - -var le = binary.LittleEndian - -// Used throughout the various DBs. -const ( - slotSize = 4 * 4 - slotStart = 2 -) - -// CheckMagic reports whether the Reader starts with a magic header for -// a file format supported by this package. -func CheckMagic(_ context.Context, r io.Reader) bool { - const ( - xdb = 'R' | 'p'<<8 | 'm'<<16 | 'X'<<24 - pkg = 'R' | 'p'<<8 | 'm'<<16 | 'P'<<24 - ) - b := make([]byte, 4) - if _, err := io.ReadFull(r, b); err != nil { - return false - } - m := le.Uint32(b) - return m == xdb || m == pkg -} - -// XDB is the "xdb" a.k.a. "Index.db", the ndb mechanism for creating indexes. -type XDB struct { - r io.ReaderAt - lookup map[rpm.Tag]*xdbSlot - slot []xdbSlot - xdbHeader -} - -// Parse closes over the passed [io.ReaderAt] and populates the XDB. -func (db *XDB) Parse(r io.ReaderAt) error { - const headerSize = 32 - h := make([]byte, headerSize) - if _, err := r.ReadAt(h, 0); err != nil { - return fmt.Errorf("xdb: unable to read header: %w", err) - } - if err := db.xdbHeader.UnmarshalBinary(h); err != nil { - return fmt.Errorf("xdb: bad header: %w", err) - } - pg := make([]byte, db.PageSize*db.SlotNPages) - if _, err := r.ReadAt(pg, 0); err != nil { - return fmt.Errorf("xdb: unable to read slots: %w", err) - } - - // Size for full pages of slots. - max := (len(pg) / slotSize) - slotStart - db.lookup = make(map[rpm.Tag]*xdbSlot, max) - db.slot = make([]xdbSlot, max) - n := 0 - var x *xdbSlot - for off := slotStart * slotSize; n < max; n, off = n+1, off+slotSize { - x = &db.slot[n] - if err := x.UnmarshalBinary(pg[off:]); err != nil { - return err - } - if x.Tag == 0 || x.Tag == rpm.TagInvalid { - break - } - db.lookup[x.Tag] = x - } - db.slot = db.slot[:n] - db.r = r - return nil -} - -// Index reports the index for the specified tag. -func (db *XDB) Index(tag rpm.Tag) (*Index, error) { - slot, ok := db.lookup[tag] - if !ok { - return nil, fmt.Errorf("ndb: no such tag %d", tag) - } - off, ct := int64(slot.StartPage*db.PageSize), int64(slot.PageCount*db.PageSize) - r := io.NewSectionReader(db.r, off, ct) - var idx Index - if err := idx.Parse(r); err != nil { - return nil, err - } - return &idx, nil -} - -type xdbHeader struct { - Version uint32 - Generation uint32 - SlotNPages uint32 - PageSize uint32 - UserGeneration uint32 -} - -// UnmarshalBinary implements encoding.BinaryUnmarshaler for the xdb header. -func (h *xdbHeader) UnmarshalBinary(b []byte) error { - const ( - headerSz = 32 - magic = 'R' | 'p'<<8 | 'm'<<16 | 'X'<<24 - version = 0 - - offsetMagic = 0 - offsetVersion = 4 - offsetGeneration = 8 - offsetSlotNPages = 12 - offsetPageSize = 16 - offsetUserGeneration = 20 - ) - - if len(b) < headerSz { - return io.ErrShortBuffer - } - if le.Uint32(b[offsetMagic:]) != magic { - return errors.New("xdb: bad magic") - } - h.Version = le.Uint32(b[offsetVersion:]) - if h.Version != version { - return errors.New("bad version") - } - h.Generation = le.Uint32(b[offsetGeneration:]) - h.SlotNPages = le.Uint32(b[offsetSlotNPages:]) - h.PageSize = le.Uint32(b[offsetPageSize:]) - h.UserGeneration = le.Uint32(b[offsetUserGeneration:]) - return nil -} - -type xdbSlot struct { - Subtag uint8 - Tag rpm.Tag - StartPage uint32 - PageCount uint32 -} - -func (s *xdbSlot) UnmarshalBinary(b []byte) error { - const ( - magic = ('S' | 'l'<<8 | 'o'<<16 | 0x00<<24) - magicMask = ^uint32(0xFF << 24) - - magicOffset = 0 - subtagOffset = 3 - tagOffset = 4 - startOffset = 8 - countOffset = 12 - ) - if len(b) < slotSize { - return io.ErrShortBuffer - } - if le.Uint32(b[magicOffset:])&magicMask != magic { - return fmt.Errorf("slot: bad magic") - } - s.Subtag = b[subtagOffset] - s.Tag = rpm.Tag(le.Uint32(b[tagOffset:])) - s.StartPage = le.Uint32(b[startOffset:]) - s.PageCount = le.Uint32(b[countOffset:]) - return nil -} diff --git a/rpm/ndb/testdata/Index.db b/rpm/ndb/testdata/Index.db deleted file mode 100644 index ccc647631..000000000 Binary files a/rpm/ndb/testdata/Index.db and /dev/null differ diff --git a/rpm/packagescanner.go b/rpm/packagescanner.go index d581f624b..ff6db8ab7 100644 --- a/rpm/packagescanner.go +++ b/rpm/packagescanner.go @@ -3,6 +3,7 @@ package rpm import ( "context" + "errors" "fmt" "io/fs" "runtime/trace" @@ -11,6 +12,7 @@ import ( "github.com/quay/claircore" "github.com/quay/claircore/indexer" + "github.com/quay/claircore/internal/rpm" ) const ( @@ -24,7 +26,7 @@ var ( _ indexer.PackageScanner = (*Scanner)(nil) ) -// Scanner implements the scanner.PackageScanner interface. +// Scanner implements the [indexer.PackageScanner] interface. // // This looks for directories that look like rpm databases and examines the // files it finds there. @@ -32,19 +34,22 @@ var ( // The zero value is ready to use. type Scanner struct{} -// Name implements scanner.VersionedScanner. +// Name implements [indexer.VersionedScanner]. func (*Scanner) Name() string { return pkgName } -// Version implements scanner.VersionedScanner. +// Version implements [indexer.VersionedScanner]. func (*Scanner) Version() string { return pkgVersion } -// Kind implements scanner.VersionedScanner. +// Kind implements [indexer.VersionedScanner]. func (*Scanner) Kind() string { return pkgKind } // Scan attempts to find rpm databases within the layer and enumerate the // packages there. // // A return of (nil, nil) is expected if there's no rpm database. +// +// Deprecated: In-tree [indexer.PackageScanner] implementations should almost +// certainly use the "internal/rpm" and "internal/dnf" packages. func (ps *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*claircore.Package, error) { if err := ctx.Err(); err != nil { return nil, err @@ -63,32 +68,36 @@ func (ps *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*clairco return nil, fmt.Errorf("rpm: unable to open layer: %w", err) } - found := make([]foundDB, 0) - if err := fs.WalkDir(sys, ".", findDBs(ctx, &found, sys)); err != nil { - return nil, fmt.Errorf("rpm: error walking fs: %w", err) - } - if len(found) == 0 { - return nil, nil - } - - zlog.Debug(ctx).Int("count", len(found)).Msg("found possible databases") - - var pkgs []*claircore.Package - done := map[string]struct{}{} - for _, db := range found { - ctx := zlog.ContextWithValues(ctx, "db", db.String()) - zlog.Debug(ctx).Msg("examining database") - if _, ok := done[db.Path]; ok { - zlog.Debug(ctx).Msg("already seen, skipping") - continue - } - done[db.Path] = struct{}{} - ps, err := getDBObjects(ctx, sys, db, packagesFromDB) + var out []*claircore.Package + dbs, errFunc := rpm.FindDBs(ctx, sys) + defer func() { + err = errors.Join(err, errFunc()) + }() + for db := range dbs { + err = func() error { + ctx := zlog.ContextWithValues(ctx, "db", db.String()) + zlog.Debug(ctx).Msg("examining database") + db, err := rpm.OpenDB(ctx, sys, db) + switch { + case err == nil: + case errors.Is(err, fs.ErrNotExist): + return nil + default: + return err + } + defer db.Close() + for pkg, err := range db.Packages(ctx) { + if err != nil { + return err + } + out = append(out, &pkg) + } + return nil + }() if err != nil { return nil, err } - pkgs = append(pkgs, ps...) } - return pkgs, nil + return out, nil } diff --git a/rpm/packagescanner_test.go b/rpm/packagescanner_test.go index 7cce81a3c..5ecf609c4 100644 --- a/rpm/packagescanner_test.go +++ b/rpm/packagescanner_test.go @@ -107,7 +107,7 @@ func TestPackageDetection(t *testing.T) { seq := rpmtest.PackagesFromManifest(t, slices.Values(m.RPMs)) want := wart.CollectPointer(seq) - opts := rpmtest.Options(t) + opts := rpmtest.Options(t, nil) if !cmp.Equal(got, want, opts) { t.Error(cmp.Diff(got, want, opts)) } diff --git a/ruby/packagescanner.go b/ruby/packagescanner.go index 1e9f6e5ec..93100ef0e 100644 --- a/ruby/packagescanner.go +++ b/ruby/packagescanner.go @@ -103,12 +103,12 @@ func (ps *Scanner) Scan(ctx context.Context, layer *claircore.Layer) ([]*clairco } var ret []*claircore.Package - fc, err := rpm.NewFileChecker(ctx, layer) + set, err := rpm.NewPathSet(ctx, layer) if err != nil { return nil, fmt.Errorf("ruby: unable to check RPM db: %w", err) } for _, g := range gs { - if fc.IsRPM(g) { + if set.Contains(g) { zlog.Debug(ctx). Str("path", g). Msg("file path determined to be of RPM origin") diff --git a/test/periodic/rpm_test.go b/test/periodic/rpm_test.go index ec7b7dd78..8f1e12254 100644 --- a/test/periodic/rpm_test.go +++ b/test/periodic/rpm_test.go @@ -15,7 +15,7 @@ import ( "github.com/quay/zlog" "github.com/quay/claircore" - "github.com/quay/claircore/rpm" + "github.com/quay/claircore/rhel" "github.com/quay/claircore/test" "github.com/quay/claircore/test/fetch" "github.com/quay/claircore/test/rpmtest" @@ -25,6 +25,8 @@ import ( // container images, then fetches and indexes the manifest and compares it to // the published RPM manifest for the image. func TestRPMSpotCheck(t *testing.T) { + // TODO(hank) This should be unified with the + // "test/cmd/fetch-container-rpm-manifest" command. ctx := context.Background() // This is the URL for our search query. Needs to get Solr search parameters // added to the RawQuery member. @@ -220,7 +222,7 @@ func (doc hydraDoc) Run(dir string) func(*testing.T) { want := rpmtest.PackagesFromRPMManifest(t, io.TeeReader(res.Body, buf)) defer logResponse(t, res.Request.URL.Path, buf)() - s := &rpm.Scanner{} + s := &rhel.PackageScanner{} pkgMap := map[string]*claircore.Package{} var which claircore.Digest for i := len(image.Data[0].Parsed.Layers) - 1; i >= 0; i-- { @@ -260,7 +262,7 @@ func (doc hydraDoc) Run(dir string) func(*testing.T) { if len(want) != len(got) { t.Errorf("wanted %d packages but got %d", len(want), len(got)) } - opts := rpmtest.Options(t) + opts := rpmtest.Options(t, nil) if !cmp.Equal(got, want, opts) { t.Error(cmp.Diff(got, want, opts)) } diff --git a/test/redhat/catalog/catalog.go b/test/redhat/catalog/catalog.go index 981793b3f..3859dc21b 100644 --- a/test/redhat/catalog/catalog.go +++ b/test/redhat/catalog/catalog.go @@ -211,7 +211,7 @@ type ParsedData struct { OS string `json:"os"` Ports string `json:"ports"` // Repositories defined within an image as reported by yum command. - Repos []TODO `json:"repos"` + Repos []ParsedDataRepo `json:"repos"` // Size of this image as reported by image metadata. Size int64 `json:"size"` // Information about uncompressed layer sizes. @@ -224,6 +224,31 @@ type ParsedData struct { VirtualSize int64 `json:"virtual_size"` } +// BUG(hank) The [ParsedData.Layers] slice is backwards: the last-applied layer +// is at the 0th position. OCI types have the first-applied layer in the 0th +// position. + +// TopLayer is a helper to work around the layer notation difference. +// +// See the BUG note for more information. +func (d *ParsedData) TopLayer() string { + return d.Layers[0] +} + +// ParsedDataRepo has no description. +// +// Implements the object described at https://catalog.redhat.com/api/containers/docs/objects/ParsedDataRepo.html +type ParsedDataRepo struct { + BaseURL string `json:"baseurl"` + Expire string `json:"expire"` + Filename string `json:"filename"` + ID string `json:"id"` + Name string `json:"name"` + Packages string `json:"pkgs"` + Size string `json:"size"` + Updated string `json:"updated"` +} + // RpmManifest contains all the RPM packages for a given [Image]. // // Implements the object described at https://catalog.redhat.com/api/containers/docs/objects/ContainerImageRPMManifest.html diff --git a/test/rpmtest/archive.go b/test/rpmtest/archive.go index b54cfdab7..85b442e9f 100644 --- a/test/rpmtest/archive.go +++ b/test/rpmtest/archive.go @@ -13,9 +13,15 @@ import ( "path" "slices" "strings" + "testing" + "github.com/google/go-cmp/cmp" + "github.com/quay/zlog" "golang.org/x/tools/txtar" + "github.com/quay/claircore" + "github.com/quay/claircore/internal/wart" + "github.com/quay/claircore/test" "github.com/quay/claircore/test/redhat/catalog" "github.com/quay/claircore/test/redhat/hydra" ) @@ -169,3 +175,101 @@ func (a *Archive) Repository() (catalog.Repository, error) { } return r, errors.New("no repository object") } + +// Tests runs "tf" on images described in the archive and checks the output with +// the relevant rpm manifest in the archive. +func (a *Archive) Tests( + ctx context.Context, + ca *test.CachedArena, + repoAllow map[string][]string, + tf func(context.Context, *claircore.Layer) ([]*claircore.Package, error), +) func(*testing.T) { + if repoAllow == nil { + repoAllow = make(map[string][]string) + } + return func(t *testing.T) { + for _, ref := range a.Repositories() { + t.Run(ref, func(t *testing.T) { + t.Parallel() + + arches := map[string]struct{}{} + reg, repo, _ := strings.Cut(ref, "/") + imgs, err := a.Image(reg, repo) + if err != nil { + t.Fatal(err) + } + + for _, img := range imgs.Data { + // Only consider the first listed instance of an + // architecture, since that's the only rpm manifest that + // will be populated. + if _, skip := arches[img.Archtecture]; skip { + continue + } + arches[img.Archtecture] = struct{}{} + + t.Run(img.Archtecture, func(t *testing.T) { + ctx := zlog.Test(ctx, t) + m, err := a.Manifest(img.ID) + if err != nil { + t.Fatal(err) + } + + repos := repoAllow[ref] + for _, r := range img.ParsedData.Repos { + repos = append(repos, r.ID) + } + t.Logf("allowlisting rpm repositories: %#v", repos) + + var got []*claircore.Package + // Find the top-most layer that returns results. + for i, digest := range img.ParsedData.Layers { + layerRef := test.LayerRef{ + Registry: reg, + Name: repo, + Digest: digest, + } + + // Fetch the layer via the test caching machinery. + ca.LoadLayerFromRegistry(ctx, t, layerRef) + r := ca.Realizer(ctx).(*test.CachedRealizer) + t.Cleanup(func() { + if err := r.Close(); err != nil { + t.Error(err) + } + }) + ls, err := r.RealizeDescriptions(ctx, []claircore.LayerDescription{ + { + Digest: digest, + URI: "http://example.com", + MediaType: test.MediaType, + Headers: make(map[string][]string), + }, + }) + if err != nil { + t.Fatal(err) + } + + got, err = tf(ctx, &ls[0]) + if err != nil { + t.Error(err) + } + if len(got) != 0 { + break + } + t.Logf("skipped layer %d (%s): no packages", i+1, digest) + } + + seq := PackagesFromManifest(t, slices.Values(m.RPMs)) + want := wart.CollectPointer(seq) + + opts := Options(t, repos) + if !cmp.Equal(got, want, opts) { + t.Error(cmp.Diff(got, want, opts)) + } + }) + } + }) + } + } +} diff --git a/test/rpmtest/options.go b/test/rpmtest/options.go index 3bf2776ca..3914cddf9 100644 --- a/test/rpmtest/options.go +++ b/test/rpmtest/options.go @@ -3,6 +3,7 @@ package rpmtest import ( "net/url" "reflect" + "slices" "sync" "testing" @@ -16,11 +17,11 @@ import ( // Options is a standard set of [cmp.Options] for working with packages from // rpm. The passed [testing.TB] is captured, so the returned Options cannot be // reused across tests. -func Options(t testing.TB) cmp.Options { +func Options(t testing.TB, repos []string) cmp.Options { return cmp.Options{ - HintCompare(t), + HintCompare(t, repos), VersionTransform(t), - IgnorePackageDB, + IgnoreFields, SortPackages, ModuleCompare, } @@ -30,7 +31,14 @@ func Options(t testing.TB) cmp.Options { // // The RPM manifest doesn't have checksum information. It does have keyid // information, so normalize down to the common set. -func HintCompare(t testing.TB) cmp.Option { +func HintCompare(t testing.TB, repos []string) cmp.Option { + const ( + keyHash = `hash` + keyRepo = `repoid` + ) + if repos != nil { + slices.Sort(repos) + } return cmp.FilterPath( func(p cmp.Path) bool { return p.Last().String() == ".RepositoryHint" }, cmp.Comparer(func(a, b string) bool { @@ -42,13 +50,50 @@ func HintCompare(t testing.TB) cmp.Option { if err != nil { t.Errorf("%q: %v", b, err) } - av.Del("hash") - bv.Del("hash") + + // Ignore "hash" keys. + av.Del(keyHash) + bv.Del(keyHash) + + ar, aok := av[keyRepo] + br, bok := bv[keyRepo] + switch { + case aok == bok: // Let the normal compare work. + case aok && !bok: + // If only the "a" values have repo values, make sure it's a + // subset of the allowed values. + if isSubset(repos, ar) { + av.Del(keyRepo) + } + case !aok && bok: + // Ditto for the "b" values. + if isSubset(repos, br) { + bv.Del(keyRepo) + } + } + return cmp.Equal(av.Encode(), bv.Encode()) }), ) } +// IsSubset reports if "sub" is a subset or equal to "super". +// +// It's assumed the slices are "set-like," meaning they do not contain +// duplicated elements, although this is not checked. +func isSubset[S ~[]E, E comparable](super, sub S) bool { + if super == nil || len(super) < len(sub) { + return false + } + n := 0 + for _, e := range sub { + if slices.Contains(super, e) { + n++ + } + } + return n == len(sub) +} + // VersionTransform turns a [Package.Version] into [rpmver.Version]. Go-cmp // produces sensible output on [rpmver.Version] objects. func VersionTransform(t testing.TB) cmp.Option { @@ -95,5 +140,5 @@ var ( SortPackages = cmpopts.SortSlices(func(a, b *claircore.Package) bool { return a.Name < b.Name }) - IgnorePackageDB = cmpopts.IgnoreFields(claircore.Package{}, ".PackageDB") + IgnoreFields = cmpopts.IgnoreFields(claircore.Package{}, ".PackageDB") )