Files
archie/internal/domain/distribution/source.go
T
sam 9d8f364af1
Quality / check (push) Successful in 5m53s
deploy / gate (push) Canceled after 0s
deploy / archied-image (push) Canceled after 0s
deploy / agent-image (push) Canceled after 0s
deploy / dist-zip (push) Canceled after 0s
feat(releaseupdate): signed OCI distribution sources for releases and the catalogue (#1715)
2026-10-31 18:18:43 +11:00

90 lines
2.9 KiB
Go

// Package distribution names where an instance takes signed artifacts from:
// its releases and its extension catalogue.
package distribution
import (
"crypto/ed25519"
"encoding/base64"
"errors"
"fmt"
"strings"
)
// Source is an OCI repository and the public key that must have signed what
// it serves. The key, not the registry, is what makes an artifact trusted, so
// a source is never valid without one.
type Source struct {
Reference string
Key ed25519.PublicKey
}
// Parse builds a source from its stored form. A blank reference and key mean
// fallback; setting only one of them is refused, since a reference without
// its key, or a key for the default reference, is a misconfiguration.
func Parse(reference, key string, fallback Source) (Source, error) {
reference, key = strings.TrimSpace(reference), strings.TrimSpace(key)
if reference == "" && key == "" {
return fallback, nil
}
if reference == "" || key == "" {
return Source{}, errors.New("a distribution source needs both a reference and a key")
}
if !repository(reference) {
return Source{}, fmt.Errorf("distribution source %q must be an OCI repository such as registry.example/owner/name", reference)
}
decoded, err := ParseKey(key)
if err != nil {
return Source{}, err
}
return Source{Reference: reference, Key: decoded}, nil
}
// ParseKey decodes a base64 ed25519 public key.
func ParseKey(key string) (ed25519.PublicKey, error) {
decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(key))
if err != nil || len(decoded) != ed25519.PublicKeySize {
return nil, errors.New("distribution key must be a base64 ed25519 public key")
}
return decoded, nil
}
// EncodeKey is the stored form of a public key.
func EncodeKey(key ed25519.PublicKey) string {
return base64.StdEncoding.EncodeToString(key)
}
// repository accepts registry/path with an optional registry port and no tag
// or digest: a source names a repository, and its tags are the channels.
func repository(reference string) bool {
host, path, ok := strings.Cut(reference, "/")
return ok && host != "" && path != "" &&
strings.Count(host, ":") <= 1 && !strings.ContainsAny(path, ":@") &&
!strings.ContainsAny(reference, " \t\n") && !strings.Contains(reference, "//")
}
// mustKey decodes a built-in key; a malformed one is a build defect.
func mustKey(encoded string) ed25519.PublicKey {
key, err := ParseKey(encoded)
if err != nil {
panic("distribution: invalid built-in key")
}
return key
}
// DefaultCatalogue is the archipelago marketplace an instance trusts until an
// operator names another.
func DefaultCatalogue() Source {
return Source{
Reference: "git.catlow.cloud/sam/archipelago/catalogue",
Key: mustKey("YL4nvn07uq/5mXZOt9cEmLYu/kB6C2+MLTnbHyoX4Pw="),
}
}
// DefaultReleases is where Archie's own releases are published.
func DefaultReleases() Source {
return Source{
Reference: "git.catlow.cloud/sam/archie",
Key: mustKey("gIBqoQMwy+8WXmGfiuHtnUa50W0IqfzkTR6iF5q3dSM="),
}
}