116 lines
4.3 KiB
Go
116 lines
4.3 KiB
Go
package releaseupdate
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ed25519"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
digest "github.com/opencontainers/go-digest"
|
|
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
|
|
"oras.land/oras-go/v2/errdef"
|
|
"oras.land/oras-go/v2/registry/remote"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/distribution"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
|
|
)
|
|
|
|
// Promote points the stable tag at a published release. The signature covers
|
|
// the release statement, not the tag, so the release doesn't need signing
|
|
// again. It refuses a prerelease, and a release issued before the one stable
|
|
// already points at, which hosts would reject as a replay.
|
|
//
|
|
// Each image repository in latest gets its v<version> tag copied to latest
|
|
// before stable moves, so if that fails stable is unchanged and running
|
|
// Promote again finishes the job.
|
|
func Promote(ctx context.Context, repository string, key ed25519.PublicKey, version string, latest []string) (Statement, error) {
|
|
source := distribution.Source{Reference: repository, Key: key}
|
|
release, err := Fetch(ctx, source, Tag("exact-pin", version))
|
|
if err != nil {
|
|
return Statement{}, err
|
|
}
|
|
if release.Statement.Prerelease {
|
|
return Statement{}, fmt.Errorf("%s is a prerelease and never reaches stable", version)
|
|
}
|
|
current, err := Fetch(ctx, source, "stable")
|
|
switch {
|
|
case errors.Is(err, errdef.ErrNotFound):
|
|
case err != nil:
|
|
return Statement{}, err
|
|
case release.Statement.IssuedAt.Before(current.Statement.IssuedAt):
|
|
return Statement{}, fmt.Errorf("%s was issued before %s, which stable names", version, current.Statement.Version)
|
|
}
|
|
repo, err := pushRepository(repository)
|
|
if err != nil {
|
|
return Statement{}, err
|
|
}
|
|
desc, err := verifiedManifest(ctx, repo, version, release.Artifact.Statement, key)
|
|
if err != nil {
|
|
return Statement{}, err
|
|
}
|
|
for _, image := range latest {
|
|
if err := promoteImage(ctx, image, version, release.Statement.AgentImage); err != nil {
|
|
return Statement{}, err
|
|
}
|
|
}
|
|
if err := repo.Tag(ctx, desc, "stable"); err != nil {
|
|
return Statement{}, fmt.Errorf("tag stable: %w", err)
|
|
}
|
|
return release.Statement, nil
|
|
}
|
|
|
|
// promoteImage tags image:v<version> as latest. The agent image must be the
|
|
// one the statement pins, or latest would name an image the release never
|
|
// signed for.
|
|
func promoteImage(ctx context.Context, image, version, agentImage string) error {
|
|
repo, err := pushRepository(image)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
desc, err := repo.Resolve(ctx, Tag("exact-pin", version))
|
|
if err != nil {
|
|
return fmt.Errorf("resolve %s:v%s: %w", image, version, err)
|
|
}
|
|
if pinned, digest, ok := strings.Cut(agentImage, "@"); ok && pinned == image && desc.Digest.String() != digest {
|
|
return fmt.Errorf("%s:v%s is %s, not the %s the release pins", image, version, desc.Digest, digest)
|
|
}
|
|
if err := repo.Tag(ctx, desc, "latest"); err != nil {
|
|
return fmt.Errorf("tag %s:latest: %w", image, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// verifiedManifest returns the manifest the version tag points at now, after
|
|
// checking it carries the statement that was already verified. This stops a
|
|
// tag that moved in the meantime from putting an unverified manifest on
|
|
// stable.
|
|
func verifiedManifest(ctx context.Context, repo *remote.Repository, version string, statement []byte, key ed25519.PublicKey) (ocispec.Descriptor, error) {
|
|
desc, err := repo.Resolve(ctx, Tag("exact-pin", version))
|
|
if err != nil {
|
|
return ocispec.Descriptor{}, fmt.Errorf("resolve %s: %w", version, err)
|
|
}
|
|
stream, err := repo.Fetch(ctx, desc)
|
|
if err != nil {
|
|
return ocispec.Descriptor{}, fmt.Errorf("fetch %s manifest: %w", version, err)
|
|
}
|
|
raw, err := io.ReadAll(io.LimitReader(stream, desc.Size))
|
|
_ = stream.Close()
|
|
if err != nil {
|
|
return ocispec.Descriptor{}, fmt.Errorf("read %s manifest: %w", version, err)
|
|
}
|
|
if digest.FromBytes(raw) != desc.Digest {
|
|
return ocispec.Descriptor{}, fmt.Errorf("%s manifest doesn't match its digest", version)
|
|
}
|
|
var manifest ocispec.Manifest
|
|
if err := json.Unmarshal(raw, &manifest); err != nil {
|
|
return ocispec.Descriptor{}, fmt.Errorf("%s manifest: %w", version, err)
|
|
}
|
|
if err := signedoci.Verify(manifest, statement, key, Annotation); err != nil {
|
|
return ocispec.Descriptor{}, fmt.Errorf("%s changed while promoting: %w", version, err)
|
|
}
|
|
return desc, nil
|
|
}
|