Files
archie/internal/app/archied/release.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

113 lines
3.7 KiB
Go

package archied
import (
"context"
"crypto/ed25519"
"encoding/base64"
"flag"
"fmt"
"io"
"os"
"strings"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
const releaseUsage = `usage: archied release <command>
keygen -seed FILE write a new signing key's seed to FILE and print its public key
publish sign a release and push it to a release source`
// RunRelease is the publisher's side of a release source: it makes the key
// a source signs with and pushes signed releases to it.
func RunRelease(args []string, out, stderr io.Writer) int {
if len(args) == 0 {
fmt.Fprintln(stderr, releaseUsage)
return 2
}
switch args[0] {
case "keygen":
return runReleaseKeygen(args[1:], out, stderr)
case "publish":
return runReleasePublish(args[1:], out, stderr)
default:
fmt.Fprintln(stderr, releaseUsage)
return 2
}
}
// runReleaseKeygen writes the seed to a new file only, never to output, so
// the private half is not left in a terminal or CI log.
func runReleaseKeygen(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release keygen", flag.ContinueOnError)
flags.SetOutput(stderr)
seedPath := flags.String("seed", "", "file to create with the base64 private key seed")
if err := flags.Parse(args); err != nil {
return 2
}
if *seedPath == "" {
fmt.Fprintln(stderr, "release keygen: -seed is required")
return 2
}
public, private, err := ed25519.GenerateKey(nil)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
file, err := os.OpenFile(*seedPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
_, err = fmt.Fprintln(file, base64.StdEncoding.EncodeToString(private.Seed()))
if closeErr := file.Close(); err == nil {
err = closeErr
}
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintln(out, distribution.EncodeKey(public))
return 0
}
func runReleasePublish(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release publish", flag.ContinueOnError)
flags.SetOutput(stderr)
var req releaseupdate.PublishRequest
flags.StringVar(&req.Repository, "source", "", "OCI repository to publish to")
seedEnv := flags.String("seed-env", "ARCHIE_RELEASE_SEED", "environment variable holding the base64 private key seed")
flags.StringVar(&req.Version, "version", "", "release version")
flags.BoolVar(&req.Prerelease, "prerelease", false, "publish to next only")
flags.StringVar(&req.ZipPath, "zip", "", "distribution zip")
flags.StringVar(&req.AgentImage, "agent-image", "", "agent image pinned by digest")
flags.StringVar(&req.Changelog, "changelog", "", "URL of the release notes")
if err := flags.Parse(args); err != nil {
return 2
}
if req.Repository == "" || req.Version == "" || req.ZipPath == "" || req.AgentImage == "" {
fmt.Fprintln(stderr, "release publish: -source, -version, -zip and -agent-image are required")
return 2
}
seed, err := base64.StdEncoding.DecodeString(strings.TrimSpace(os.Getenv(*seedEnv)))
if err != nil || len(seed) != ed25519.SeedSize {
fmt.Fprintf(stderr, "release publish: %s must hold a base64 ed25519 seed\n", *seedEnv)
return 2
}
req.Signer = ed25519.NewKeyFromSeed(seed)
public := distribution.EncodeKey(ed25519.PublicKey(req.Signer[ed25519.SeedSize:]))
req.Channels = []string{"next"}
if !req.Prerelease {
req.Channels = append(req.Channels, "stable")
}
statement, err := releaseupdate.Publish(context.Background(), req)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintf(out, "published %s to %s (%s) with key %s\n", statement.Version, req.Repository,
strings.Join(req.Channels, ", "), public)
return 0
}