fix(script): enforce script body limits without streaming

Streaming accepted a chunked body cut at a chunk boundary as complete,
so the limit now comes from the client that reads the body, picked per
requested size. Script requests keep their own default, maxBodySize
accepts sizes like 10MiB, and files sarin downloads for itself are
capped at 64MiB.

internal/config/bytesize.go

@@ -3,9 +3,6 @@ package config
 import (
 	"flag"
 	"fmt"
-	"math"
-	"strconv"
-	"strings"
 
 	"go.aykhans.me/sarin/internal/types"
 	"go.yaml.in/yaml/v4"
@@ -19,84 +16,13 @@ var (
 // byteSize is a size in bytes that reads and prints unit suffixes such as 10MiB.
 type byteSize uint64
 
-// byteSizeUnits run from the largest scale down, so formatting picks the largest unit
-// that fits. A bare "K" is out: the common libraries disagree on whether it counts
-// 1000 or 1024 bytes.
-var byteSizeUnits = []struct {
-	suffix string
-	scale  uint64
-}{
-	{"TiB", 1 << 40},
-	{"TB", 1000 * 1000 * 1000 * 1000},
-	{"GiB", 1 << 30},
-	{"GB", 1000 * 1000 * 1000},
-	{"MiB", 1 << 20},
-	{"MB", 1000 * 1000},
-	{"KiB", 1 << 10},
-	{"KB", 1000},
-	{"B", 1},
-}
-
-// parseByteSize reads a byte count, with or without a unit suffix.
-func parseByteSize(value string) (uint64, error) {
-	text := strings.TrimSpace(value)
-
-	// The suffix is split off by index, so no case mapping can shift the digits.
-	digitsEnd := len(text)
-	for digitsEnd > 0 && isASCIILetter(text[digitsEnd-1]) {
-		digitsEnd--
-	}
-
-	scale := uint64(1)
-	if suffix := text[digitsEnd:]; suffix != "" {
-		unitScale, ok := byteSizeScale(suffix)
-		if !ok {
-			return 0, types.ErrByteSizeInvalid
-		}
-		scale = unitScale
-	}
-
-	size, err := strconv.ParseUint(strings.TrimSpace(text[:digitsEnd]), 10, 64)
-	if err != nil {
-		return 0, types.ErrByteSizeInvalid
-	}
-	if size > math.MaxUint64/scale {
-		return 0, types.ErrByteSizeInvalid
-	}
-	return size * scale, nil
-}
-
-// byteSizeScale looks up a unit suffix, ignoring case.
-func byteSizeScale(suffix string) (uint64, bool) {
-	for _, unit := range byteSizeUnits {
-		if strings.EqualFold(suffix, unit.suffix) {
-			return unit.scale, true
-		}
-	}
-	return 0, false
-}
-
-func isASCIILetter(char byte) bool {
-	return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')
-}
-
-// formatByteSize renders a byte count so that parseByteSize reads back the same value.
-func formatByteSize(size uint64) string {
-	for _, unit := range byteSizeUnits {
-		if unit.scale > 1 && size >= unit.scale && size%unit.scale == 0 {
-			return strconv.FormatUint(size/unit.scale, 10) + unit.suffix
-		}
-	}
-	return strconv.FormatUint(size, 10)
-}
-
 func (size byteSize) String() string {
-	return formatByteSize(uint64(size))
+	return types.FormatByteSize(uint64(size))
 }
 
 // Set fills the size from a command line value.
 func (size *byteSize) Set(value string) error {
-	parsed, err := parseByteSize(value)
+	parsed, err := types.ParseByteSize(value)
 	if err != nil {
 		return err
 	}

internal/config/cli.go

@@ -293,7 +293,7 @@ func (parser ConfigCLIParser) PrintHelp() {
 
 		Defaults.Method,
 		Defaults.RequestTimeout,
-		formatByteSize(Defaults.MaxResponseBody),
+		types.FormatByteSize(Defaults.MaxResponseBody),
 		Defaults.Insecure,
 	)
 }

internal/config/config.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -59,8 +58,6 @@ var (
 	ValidLogLevels         = []string{"info", "error"}
 )
 
-const maxResponseBodyLimit = min(1<<40, math.MaxInt) // 1 TiB on 64 bit, 2 GiB - 1 on 32 bit
-
 var (
 	StyleYellow = lipgloss.NewStyle().Foreground(lipgloss.Color("220"))
 	StyleRed    = lipgloss.NewStyle().Foreground(lipgloss.Color("196"))
@@ -184,7 +181,7 @@ func (config Config) MarshalYAML() (any, error) {
 		addField(content, "timeout", toNode(*config.Timeout), "")
 	}
 	if config.MaxResponseBody != nil {
-		addField(content, "maxResponseBody", toNode(formatByteSize(*config.MaxResponseBody)), "")
+		addField(content, "maxResponseBody", toNode(types.FormatByteSize(*config.MaxResponseBody)), "")
 	}
 	if config.Concurrency != nil {
 		addField(content, "concurrency", toNode(*config.Concurrency), "")
@@ -469,11 +466,11 @@ func (config Config) Validate() error {
 		validationErrors = append(validationErrors, types.NewFieldValidationError("Timeout", "0", errors.New("timeout must be greater than 0")))
 	}
 
-	if config.MaxResponseBody != nil && *config.MaxResponseBody > maxResponseBodyLimit {
+	if config.MaxResponseBody != nil && *config.MaxResponseBody > types.ByteSizeLimit {
 		validationErrors = append(validationErrors, types.NewFieldValidationError(
 			"MaxResponseBody",
-			formatByteSize(*config.MaxResponseBody),
-			errors.New("max response body must not exceed "+formatByteSize(maxResponseBodyLimit)),
+			types.FormatByteSize(*config.MaxResponseBody),
+			errors.New("max response body must not exceed "+types.FormatByteSize(types.ByteSizeLimit)),
 		))
 	}
 

internal/config/env.go

@@ -196,7 +196,7 @@ func (parser ConfigENVParser) Parse() (*Config, error) {
 	}
 
 	if maxResponseBody := parser.getEnv("MAX_RESPONSE_BODY"); maxResponseBody != "" {
-		maxResponseBodyParsed, err := parseByteSize(maxResponseBody)
+		maxResponseBodyParsed, err := types.ParseByteSize(maxResponseBody)
 		if err != nil {
 			fieldParseErrors = append(
 				fieldParseErrors,

internal/config/file.go

@@ -79,10 +79,13 @@ func fetchHTTP(ctx context.Context, url string) ([]byte, error) {
 		return nil, types.NewHTTPStatusError(url, resp.StatusCode, resp.Status)
 	}
 
-	data, err := io.ReadAll(resp.Body)
+	data, err := io.ReadAll(io.LimitReader(resp.Body, types.RemoteFetchLimit+1))
 	if err != nil {
 		return nil, types.NewHTTPFetchError(url, err)
 	}
+	if len(data) > types.RemoteFetchLimit {
+		return nil, types.NewHTTPFetchError(url, types.ErrRemoteFileTooLarge)
+	}
 
 	return data, nil
 }