0
0
package guestimage
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/netip"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"syscall"
"time"
)
const (
RequestedManifestMax = 64 << 10
RequestedBootArgsMax = 4096
RequestedDialTimeout = 10 * time.Second
RequestedHeaderTimeout = 30 * time.Second
RequestedManifestTimeout = 30 * time.Second
RequestedFetchTimeout = 30 * time.Minute
)
var ErrRequestedRefused = errors.New("guestimage: the requested image is refused")
// ErrRequestedUnavailable is a refusal that may pass: the manifest could not be fetched now (the network, the host's answer 408, 429 or
// 5xx, a cancelled or timed-out read). It is an ErrRequestedRefused too, so a boot that cannot fetch still ends as image_refused, but a bidder
// that only asks (submitRfp) does not tell the requester the image can never be served.
var ErrRequestedUnavailable = fmt.Errorf("%w (unavailable now)", ErrRequestedRefused)
func transientStatus(code int) bool {
return code == http.StatusRequestTimeout || code == http.StatusTooManyRequests || code >= 500
}
type Requested struct {
URL string `json:"url"`
SHA256 string `json:"sha256"`
}
func (r Requested) Valid() error {
u, err := url.Parse(r.URL)
switch {
case err != nil:
return fmt.Errorf("%w: the url %q: %v", ErrRequestedRefused, r.URL, err)
case u.Scheme != "https" || u.Hostname() == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "":
return fmt.Errorf("%w: the url %q is not a plain https base", ErrRequestedRefused, r.URL)
case len(r.SHA256) != SHA256HexLen || strings.Trim(r.SHA256, "0123456789abcdef") != "":
return fmt.Errorf("%w: the sha256 %q is not 64 lowercase hex digits", ErrRequestedRefused, r.SHA256)
}
return nil
}
var cgnat = netip.MustParsePrefix("100.64.0.0/10")
func PublicAddr(a netip.Addr) bool {
a = a.Unmap()
return a.IsGlobalUnicast() && !a.IsPrivate() && !cgnat.Contains(a)
}
func PublicClient() *http.Client {
dialer := &net.Dialer{Timeout: RequestedDialTimeout, Control: func(_, address string, _ syscall.RawConn) error {
ap, err := netip.ParseAddrPort(address)
if err != nil || !PublicAddr(ap.Addr()) {
return fmt.Errorf("%w: %s is not a public address", ErrRequestedRefused, address)
}
return nil
}}
return &http.Client{
Transport: &http.Transport{DialContext: dialer.DialContext, TLSHandshakeTimeout: RequestedDialTimeout,
ResponseHeaderTimeout: RequestedHeaderTimeout, ForceAttemptHTTP2: true},
CheckRedirect: func(req *http.Request, via []*http.Request) error {
if req.URL.Scheme != "https" || len(via) >= 5 {
return fmt.Errorf("%w: a redirect to %s", ErrRequestedRefused, req.URL)
}
return nil
},
}
}
type fetchedManifest struct {
manifest Manifest
bytes int64
}
var (
manifestMu sync.Mutex
manifests = map[Requested]fetchedManifest{}
)
const manifestsMax = 256
func FetchManifest(ctx context.Context, client *http.Client, req Requested) (Manifest, int64, error) {
if err := req.Valid(); err != nil {
return Manifest{}, 0, err
}
manifestMu.Lock()
held, ok := manifests[req]
manifestMu.Unlock()
if ok {
return held.manifest, held.bytes, nil
}
ctx, cancel := context.WithTimeout(ctx, RequestedManifestTimeout)
defer cancel()
get, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimSuffix(req.URL, "/")+"/"+ManifestName, nil)
if err != nil {
return Manifest{}, 0, err
}
resp, err := client.Do(get)
if err != nil {
// a dial to a non-public address or a redirect is refused for good (the client says so); a network, DNS, TLS or timeout error may pass
kind := ErrRequestedUnavailable
if errors.Is(err, ErrRequestedRefused) {
kind = ErrRequestedRefused
}
return Manifest{}, 0, fmt.Errorf("%w: fetching %s: %w", kind, get.URL, err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
kind := ErrRequestedRefused
if transientStatus(resp.StatusCode) {
kind = ErrRequestedUnavailable
}
return Manifest{}, 0, fmt.Errorf("%w: GET %s answered %s", kind, get.URL, resp.Status)
}
raw, err := io.ReadAll(io.LimitReader(resp.Body, RequestedManifestMax+1))
if err != nil {
return Manifest{}, 0, fmt.Errorf("%w: reading %s: %w", ErrRequestedUnavailable, get.URL, err)
}
if len(raw) > RequestedManifestMax {
return Manifest{}, 0, fmt.Errorf("%w: %s is over %d bytes", ErrRequestedRefused, get.URL, RequestedManifestMax)
}
sum := sha256.Sum256(raw)
if got := hex.EncodeToString(sum[:]); got != req.SHA256 {
return Manifest{}, 0, fmt.Errorf("%w: %s hashes to %s, not the requested %s", ErrRequestedRefused, get.URL, got, req.SHA256)
}
var m struct {
Manifest
Bake json.RawMessage `json:"bake"`
Inputs json.RawMessage `json:"inputs"`
}
if err := json.Unmarshal(raw, &m); err != nil {
return Manifest{}, 0, fmt.Errorf("%w: %s: %w", ErrRequestedRefused, get.URL, err)
}
manifestMu.Lock()
if len(manifests) >= manifestsMax {
clear(manifests)
}
manifests[req] = fetchedManifest{manifest: m.Manifest, bytes: int64(len(raw))}
manifestMu.Unlock()
return m.Manifest, int64(len(raw)), nil
}
func (m Manifest) CheckFor(pin Pin, capBytes int64) error {
file := func(f FileRecord, name string) error {
if f.File != name || len(f.SHA256) != SHA256HexLen || strings.Trim(f.SHA256, "0123456789abcdef") != "" || f.Bytes <= 0 {
return fmt.Errorf("%w: its %s is not {file %s, a lowercase hex sha256, bytes > 0}", ErrRequestedRefused, name, name)
}
return nil
}
switch {
case m.Target != pin.Target || m.Hypervisor != pin.Hypervisor || m.Arch != pin.Arch:
return fmt.Errorf("%w: it is for %s (%s %s); this bidder boots %s (%s %s)", ErrRequestedRefused,
m.Target, m.Hypervisor, m.Arch, pin.Target, pin.Hypervisor, pin.Arch)
case m.Vcpu <= 0 || m.MemMiB <= 0:
return fmt.Errorf("%w: it names no vcpu or memMiB", ErrRequestedRefused)
case len(m.BootArgs) == 0 || len(strings.Join(m.BootArgs, " ")) > RequestedBootArgsMax:
return fmt.Errorf("%w: its bootArgs are empty or over %d bytes", ErrRequestedRefused, RequestedBootArgsMax)
}
if err := file(m.Kernel, KernelName); err != nil {
return err
}
if err := file(m.Rootfs, RootfsName); err != nil {
return err
}
if capBytes <= 0 || m.Kernel.Bytes > capBytes-m.Rootfs.Bytes {
return fmt.Errorf("%w: its kernel and rootfs are %d bytes, over the %d bytes of the requested disk", ErrRequestedRefused,
m.Kernel.Bytes+m.Rootfs.Bytes, capBytes)
}
return nil
}
func (m Manifest) PinFor(pin Pin, req Requested, manifestBytes int64) Pin {
return Pin{Target: pin.Target, Hypervisor: pin.Hypervisor, Arch: pin.Arch, Files: map[string]FilePin{
ManifestName: {SHA256: req.SHA256, Bytes: manifestBytes},
KernelName: {SHA256: m.Kernel.SHA256, Bytes: m.Kernel.Bytes},
RootfsName: {SHA256: m.Rootfs.SHA256, Bytes: m.Rootfs.Bytes},
}}
}
func (s Store) EnsureRequested(ctx context.Context, req Requested, pin Pin, capBytes int64) (Result, error) {
ctx, cancel := context.WithTimeout(ctx, RequestedFetchTimeout)
defer cancel()
s.Client = PublicClient()
m, n, err := FetchManifest(ctx, s.Client, req)
if err != nil {
return Result{}, err
}
if err := m.CheckFor(pin, capBytes); err != nil {
return Result{}, err
}
res, err := s.Ensure(ctx, m.PinFor(pin, req, n), req.URL)
if err != nil {
return Result{}, fmt.Errorf("%w: %w", ErrRequestedRefused, err)
}
if f, err := os.OpenFile(filepath.Join(res.Dir, RequestedName), os.O_CREATE|os.O_WRONLY, 0o644); err == nil {
f.Close()
}
s.Touch(res.Dir)
return res, nil
}