Files
sam db346b159d fix(webui): mark cookies Secure behind a TLS proxy; run gosec in the gate (#1919)
Cookies took Secure from r.TLS, which is nil behind a proxy that terminates
TLS, so sign-in cookies went out without it. Every dashboard cookie now goes
through one builder that reads the scheme the way the origin check does.

The worktree reset and the agent worker's chown walk use os.Root, so a
symlink swapped in mid-walk can't point them outside the worktree.

gosec runs in golangci-lint, tests included. G104, G115, G204 and G304 are
excluded in config; each remaining finding is fixed or suppressed at the site
with its reason.
2026-11-13 03:16:15 +11:00

134 lines
4.5 KiB
Go

package releaseupdate
import (
"bytes"
"context"
"crypto/ed25519"
"encoding/base64"
"encoding/json"
"fmt"
"os"
"time"
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/registry/remote"
"oras.land/oras-go/v2/registry/remote/auth"
"oras.land/oras-go/v2/registry/remote/credentials"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
// PublishRequest is one release to sign and push.
type PublishRequest struct {
// Repository is the OCI repository the release is pushed to.
Repository string
Signer ed25519.PrivateKey
Version string
Prerelease bool
// ZipPath is the distribution zip, named ZipName(Version).
ZipPath string
AgentImage string
Changelog string
// Channels are the moving tags pointed at this release besides its own
// version tag.
Channels []string
}
// Publish signs a statement for the release and pushes it with the zip as
// one artifact, tagged with its version and each channel. Registry
// credentials come from the Docker config, as `docker login` left them.
func Publish(ctx context.Context, req PublishRequest) (Statement, error) {
archive, err := os.ReadFile(req.ZipPath)
if err != nil {
return Statement{}, err
}
statement := Statement{
Version: req.Version, Prerelease: req.Prerelease, IssuedAt: time.Now().UTC(), Platform: Platform,
Zip: Blob{Name: ZipName(req.Version), Digest: signedoci.Digest(archive), Size: int64(len(archive))},
AgentImage: req.AgentImage, Changelog: req.Changelog,
}
if err := statement.Validate(); err != nil {
return Statement{}, err
}
for _, channel := range req.Channels {
if channel != "stable" && channel != "next" {
return Statement{}, fmt.Errorf("unknown channel %q", channel)
}
}
encoded, err := json.Marshal(statement)
if err != nil {
return Statement{}, err
}
repository, err := pushRepository(req.Repository)
if err != nil {
return Statement{}, err
}
layers := []ocispec.Descriptor{
{MediaType: StatementMediaType, Digest: digest.FromBytes(encoded), Size: int64(len(encoded))},
{
MediaType: "application/zip", Digest: digest.FromBytes(archive), Size: int64(len(archive)),
Annotations: map[string]string{ocispec.AnnotationTitle: statement.Zip.Name},
},
}
for i, content := range [][]byte{ocispec.DescriptorEmptyJSON.Data, encoded, archive} {
desc := ocispec.DescriptorEmptyJSON
if i > 0 {
desc = layers[i-1] //nolint:gosec // G602: i > 0 indexes the two layers built above.
}
if err := pushBlob(ctx, repository, desc, content); err != nil {
return Statement{}, err
}
}
manifest, err := json.Marshal(ocispec.Manifest{
SchemaVersion: 2, MediaType: ocispec.MediaTypeImageManifest,
ArtifactType: ArtifactType, Config: ocispec.DescriptorEmptyJSON, Layers: layers,
Annotations: map[string]string{
Annotation: base64.StdEncoding.EncodeToString(ed25519.Sign(req.Signer, encoded)),
ocispec.AnnotationCreated: statement.IssuedAt.Format(time.RFC3339),
},
})
if err != nil {
return Statement{}, err
}
desc := ocispec.Descriptor{MediaType: ocispec.MediaTypeImageManifest, Digest: digest.FromBytes(manifest), Size: int64(len(manifest))}
if err := repository.PushReference(ctx, desc, bytes.NewReader(manifest), Tag("exact-pin", req.Version)); err != nil {
return Statement{}, fmt.Errorf("push release manifest: %w", err)
}
for _, channel := range req.Channels {
if err := repository.Tag(ctx, desc, channel); err != nil {
return Statement{}, fmt.Errorf("tag %s: %w", channel, err)
}
}
return statement, nil
}
func pushRepository(reference string) (*remote.Repository, error) {
repository, err := remote.NewRepository(reference)
if err != nil {
return nil, err
}
repository.PlainHTTP = signedoci.Loopback(reference)
store, err := credentials.NewStoreFromDocker(credentials.StoreOptions{})
if err != nil {
return nil, fmt.Errorf("read registry credentials: %w", err)
}
repository.Client = &auth.Client{Credential: credentials.Credential(store)}
return repository, nil
}
// pushBlob uploads content unless the registry already holds it.
func pushBlob(ctx context.Context, repository *remote.Repository, desc ocispec.Descriptor, content []byte) error {
exists, err := repository.Exists(ctx, desc)
if err != nil {
return fmt.Errorf("check blob %s: %w", desc.Digest, err)
}
if exists {
return nil
}
if err := repository.Push(ctx, desc, bytes.NewReader(content)); err != nil {
return fmt.Errorf("push blob %s: %w", desc.Digest, err)
}
return nil
}