189 lines
5.7 KiB
Go
189 lines
5.7 KiB
Go
// Package storepkg fetches digest-pinned Archie packages from OCI registries.
|
|
package storepkg
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"path"
|
|
"strings"
|
|
|
|
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
|
|
"oras.land/oras-go/v2/registry/remote"
|
|
|
|
domain "github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
)
|
|
|
|
const (
|
|
maxManifestBytes = 256 << 10
|
|
maxPackageBytes = 64 << 20
|
|
)
|
|
|
|
// OCIRegistry fetches a package from an OCI registry and verifies the pinned
|
|
// manifest and sole layer before returning package content. A loopback
|
|
// registry is reached over plain HTTP; every other host over HTTPS. The digest
|
|
// pin, not the transport, is what makes the content trustworthy.
|
|
type OCIRegistry struct{}
|
|
|
|
var _ domain.Registry = OCIRegistry{}
|
|
|
|
func (OCIRegistry) Fetch(ctx context.Context, reference, pin string) (domain.Descriptor, []byte, error) {
|
|
repository, err := remote.NewRepository(reference)
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
repository.PlainHTTP = loopbackReference(reference)
|
|
_, stream, err := repository.FetchReference(ctx, pin)
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
manifest, err := readBounded(stream, maxManifestBytes)
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
var image ocispec.Manifest
|
|
if err := json.Unmarshal(manifest, &image); err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
if len(image.Layers) != 1 {
|
|
return domain.Descriptor{}, nil, errors.New("archie package must have one layer")
|
|
}
|
|
layerStream, err := repository.Fetch(ctx, image.Layers[0])
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
layer, err := readBounded(layerStream, maxPackageBytes)
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
return decodeOCI(manifest, layer, pin)
|
|
}
|
|
|
|
// loopbackReference reports whether the reference names a registry on this host.
|
|
func loopbackReference(reference string) bool {
|
|
host, _, ok := strings.Cut(reference, "/")
|
|
if !ok {
|
|
return false
|
|
}
|
|
if name, _, err := net.SplitHostPort(host); err == nil {
|
|
host = name
|
|
}
|
|
host = strings.Trim(host, "[]")
|
|
return host == "localhost" || net.ParseIP(host).IsLoopback()
|
|
}
|
|
|
|
func readBounded(stream io.ReadCloser, limit int) ([]byte, error) {
|
|
defer func() { _ = stream.Close() }()
|
|
data, err := io.ReadAll(io.LimitReader(stream, int64(limit)+1))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(data) > limit {
|
|
return nil, errors.New("package content exceeds the size limit")
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func decodeOCI(manifest, layer []byte, pin string) (domain.Descriptor, []byte, error) {
|
|
if contentDigest(manifest) != pin {
|
|
return domain.Descriptor{}, nil, errors.New("package manifest digest mismatch")
|
|
}
|
|
var image ocispec.Manifest
|
|
if err := json.Unmarshal(manifest, &image); err != nil {
|
|
return domain.Descriptor{}, nil, fmt.Errorf("decode OCI manifest: %w", err)
|
|
}
|
|
if image.SchemaVersion != 2 || len(image.Layers) != 1 {
|
|
return domain.Descriptor{}, nil, errors.New("archie package must be an OCI image with one layer")
|
|
}
|
|
blob := image.Layers[0]
|
|
if blob.Size != int64(len(layer)) || blob.Digest.String() != contentDigest(layer) {
|
|
return domain.Descriptor{}, nil, errors.New("package layer digest or size mismatch")
|
|
}
|
|
raw, ok := image.Annotations[domain.APIVersion]
|
|
if !ok {
|
|
return domain.Descriptor{}, nil, errors.New("archie package descriptor annotation is missing")
|
|
}
|
|
descriptor, err := domain.Decode(strings.NewReader(raw))
|
|
if err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
if err := validateLayer(layer, blob.MediaType, descriptor.Files); err != nil {
|
|
return domain.Descriptor{}, nil, err
|
|
}
|
|
return descriptor, layer, nil
|
|
}
|
|
|
|
func validateLayer(layer []byte, mediaType string, files []domain.File) error {
|
|
var reader io.Reader = bytes.NewReader(layer)
|
|
switch mediaType {
|
|
case ocispec.MediaTypeImageLayer:
|
|
case ocispec.MediaTypeImageLayerGzip:
|
|
gz, err := gzip.NewReader(reader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = gz.Close() }()
|
|
reader = gz
|
|
default:
|
|
return fmt.Errorf("unsupported package layer media type %q", mediaType)
|
|
}
|
|
declared := make(map[string]uint32, len(files))
|
|
for _, file := range files {
|
|
declared[file.Path] = file.Mode
|
|
}
|
|
found := make(map[string]bool, len(files))
|
|
tarReader := tar.NewReader(io.LimitReader(reader, maxPackageBytes+1))
|
|
for {
|
|
header, err := tarReader.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("read package layer: %w", err)
|
|
}
|
|
if err := validateLayerEntry(header, declared, found); err != nil {
|
|
return err
|
|
}
|
|
found[header.Name] = true
|
|
if _, err := io.Copy(io.Discard, tarReader); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if len(found) != len(files) {
|
|
return errors.New("package layer is missing a declared file")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateLayerEntry(header *tar.Header, declared map[string]uint32, found map[string]bool) error {
|
|
if header.Typeflag != tar.TypeReg {
|
|
return fmt.Errorf("package layer contains non-regular file %q", header.Name)
|
|
}
|
|
if path.Clean(header.Name) != header.Name || strings.HasPrefix(header.Name, "../") {
|
|
return fmt.Errorf("package layer contains unsafe path %q", header.Name)
|
|
}
|
|
mode, ok := declared[header.Name]
|
|
if !ok || found[header.Name] {
|
|
return fmt.Errorf("package layer contains undeclared or duplicate file %q", header.Name)
|
|
}
|
|
// The mask makes the conversion exact: the low nine bits are the
|
|
// permission bits whatever the tar header's width.
|
|
if uint32(header.Mode&0o777) != mode&0o777 {
|
|
return fmt.Errorf("package file %q mode differs from descriptor", header.Name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func contentDigest(data []byte) string {
|
|
sum := sha256.Sum256(data)
|
|
return "sha256:" + hex.EncodeToString(sum[:])
|
|
}
|