feat: global error refactoring

Fixes #2123 Fixes #2120 Fixes #2116 Fixes #2111 Fixes #2108 Fixes #2086 Fixes #2085 Fixes #2083 Fixes #2081 Fixes #2080 Fixes #2073 Fixes #2072 Fixes #2071 Fixes #2069 Fixes #2044 Fixes #2043 Fixes #2042 Fixes #2041 Fixes #2040 Fixes #2039 Fixes #2036 Fixes #2035 Fixes #2034 Fixes #2028 Fixes #2020 Fixes #1842 Fixes #1810 Fixes #1780 Fixes #1775 Fixes #1736 Fixes #1705 Fixes #1663 Fixes #1645 Fixes #1583 Fixes #1526 Fixes #1514 Fixes #1493 Fixes #1487 Fixes #959 Fixes #779 Closes #823 Closes #85 Refactor global S3 error handling around structured error types and centralized XML response generation. All S3 errors now share the common APIError base for the fields every error has: Code, HTTP status code, and Message. Non-traditional errors that need AWS-compatible XML fields now have dedicated typed errors in the s3err package. Each typed error implements the shared S3Error behavior so controllers and middleware can handle errors consistently while still emitting error-specific XML fields. Add a dedicated InvalidArgumentError type because InvalidArgument is used widely across request validation, auth, copy source handling, object lock validation, multipart validation, and header parsing. The new InvalidArgument path uses explicit InvalidArgErrorCode constants with predefined descriptions and ArgumentName values, keeping call sites readable while preserving the correct InvalidArgument XML shape and optional ArgumentValue. New structured errors added in s3err: - `AccessForbiddenError`: Method, ResourceType - `BadDigestError`: CalculatedDigest, ExpectedDigest - `BucketError`: BucketName - `ContentSHA256MismatchError`: ClientComputedContentSHA256, S3ComputedContentSHA256 - `EntityTooLargeError`: ProposedSize, MaxSizeAllowed - `EntityTooSmallError`: ProposedSize, MinSizeAllowed - `ExpiredPresignedURLError`: ServerTime, XAmzExpires, Expires - `InvalidAccessKeyIdError`: AWSAccessKeyId - `InvalidArgumentError`: Description, ArgumentName, ArgumentValue - `InvalidChunkSizeError`: Chunk, BadChunkSize - `InvalidDigestError`: ContentMD5 - `InvalidLocationConstraintError`: LocationConstraint - `InvalidPartError`: UploadId, PartNumber, ETag - `InvalidRangeError`: RangeRequested, ActualObjectSize - `InvalidTagError`: TagKey, TagValue - `KeyTooLongError`: Size, MaxSizeAllowed - `MetadataTooLargeError`: Size, MaxSizeAllowed - `MethodNotAllowedError`: Method, ResourceType, AllowedMethods - `NoSuchUploadError`: UploadId - `NoSuchVersionError`: Key, VersionId - `NotImplementedError`: Header, AdditionalMessage - `PreconditionFailedError`: Condition - `RequestTimeTooSkewedError`: RequestTime, ServerTime, MaxAllowedSkewMilliseconds - `SignatureDoesNotMatchError`: AWSAccessKeyId, StringToSign, SignatureProvided, StringToSignBytes, CanonicalRequest, CanonicalRequestBytes Fix CompleteMultipartUpload validation in the Azure backend so missing or empty `ETag` values return the appropriate S3 error instead of allowing a gateway panic. Fix presigned authentication expiration validation to compare server time in `UTC`, matching the `UTC` timestamp used by presigned URL signing. Add request ID and host ID support across S3 requests. Each request now receives AWS S3-like identifiers, returned in response headers as `x-amz-request-id` and `x-amz-id-2` and included in all XML error responses as RequestId and HostId. The generated ID structure is designed to resemble AWS S3 request IDs and host IDs. The request signature calculation/validation for streaming uploads was previously delayed until the request body was fully read, both for Authorization header authentication and presigned URLs. Now, the signature is validated immediately in the authorization middlewares without reading the request body, since the signature calculation itself does not depend on the request body. Instead, only the `x-amz-content-sha256` SHA-256 hash calculation is delayed.
2026-09-06 16:16:53 +00:00 · 2026-05-21 23:49:34 +04:00
parent eade1e3a71
commit 9f786b3c2c
132 changed files with 3511 additions and 1339 deletions
@@ -18,9 +18,7 @@ import (
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"fmt"
-	"io"
 	"os"
 	"strings"
 	"time"
@@ -39,77 +37,15 @@ const (
 	yyyymmdd      = "20060102"
 )

-// AuthReader is an io.Reader that validates the request authorization
-// once the underlying reader returns io.EOF.  This is needed for streaming
-// data requests where the data size and checksum are not known until
-// the data is completely read.
-type AuthReader struct {
-	ctx    *fiber.Ctx
-	auth   AuthData
-	secret string
-	size   int
-	r      *HashReader
-}
+func HexBytes(s string) string {
+	b := []byte(s) // raw UTF-8 bytes

-// NewAuthReader initializes an io.Reader that will verify the request
-// v4 auth when the underlying reader returns io.EOF. This postpones the
-// authorization check until the reader is consumed. So it is important that
-// the consumer of this reader checks for the auth errors while reading.
-func NewAuthReader(ctx *fiber.Ctx, r io.Reader, auth AuthData, secret string) *AuthReader {
-	var hr *HashReader
-	hashPayload := ctx.Get("X-Amz-Content-Sha256")
-	if !IsSpecialPayload(hashPayload) {
-		hr, _ = NewHashReader(r, "", HashTypeSha256Hex)
-	} else {
-		hr, _ = NewHashReader(r, "", HashTypeNone)
+	parts := make([]string, len(b))
+	for i, v := range b {
+		parts[i] = fmt.Sprintf("%02x", v)
 	}

-	return &AuthReader{
-		ctx:    ctx,
-		r:      hr,
-		auth:   auth,
-		secret: secret,
-	}
-}
-
-// Read allows *AuthReader to be used as an io.Reader
-func (ar *AuthReader) Read(p []byte) (int, error) {
-	n, err := ar.r.Read(p)
-	ar.size += n
-
-	if errors.Is(err, io.EOF) {
-		verr := ar.validateSignature()
-		if verr != nil {
-			return n, verr
-		}
-	}
-
-	return n, err
-}
-
-func (ar *AuthReader) validateSignature() error {
-	date := ar.ctx.Get("X-Amz-Date")
-	if date == "" {
-		return s3err.GetAPIError(s3err.ErrMissingDateHeader)
-	}
-
-	hashPayload := ar.ctx.Get("X-Amz-Content-Sha256")
-	if !IsSpecialPayload(hashPayload) {
-		hexPayload := ar.r.Sum()
-
-		// Compare the calculated hash with the hash provided
-		if hashPayload != hexPayload {
-			return s3err.GetAPIError(s3err.ErrContentSHA256Mismatch)
-		}
-	}
-
-	// Parse the date and check the date validity
-	tdate, err := time.Parse(iso8601Format, date)
-	if err != nil {
-		return s3err.GetAPIError(s3err.ErrMissingDateHeader)
-	}
-
-	return CheckValidSignature(ar.ctx, ar.auth, ar.secret, hashPayload, tdate, int64(ar.size), true)
+	return strings.Join(parts, " ")
 }

 const (
@@ -117,18 +53,18 @@ const (
 )

 // CheckValidSignature validates the ctx v4 auth signature
-func CheckValidSignature(ctx *fiber.Ctx, auth AuthData, secret, checksum string, tdate time.Time, contentLen int64, streamBody bool) error {
+func CheckValidSignature(ctx *fiber.Ctx, auth AuthData, secret, checksum string, tdate time.Time, contentLen int64) (string, error) {
 	signedHdrs := strings.Split(auth.SignedHeaders, ";")

 	// Create a new http request instance from fasthttp request
-	req, err := createHttpRequestFromCtx(ctx, signedHdrs, contentLen, streamBody)
+	req, err := createHttpRequestFromCtx(ctx, signedHdrs, contentLen)
 	if err != nil {
-		return fmt.Errorf("create http request from context: %w", err)
+		return "", fmt.Errorf("create http request from context: %w", err)
 	}

 	signer := v4.NewSigner()

-	signErr := signer.SignHTTP(req.Context(),
+	signMeta, err := signer.SignHTTP(req.Context(),
 		aws.Credentials{
 			AccessKeyID:     auth.Access,
 			SecretAccessKey: secret,
@@ -141,20 +77,27 @@ func CheckValidSignature(ctx *fiber.Ctx, auth AuthData, secret, checksum string,
 				options.Logger = logging.NewStandardLogger(os.Stderr)
 			}
 		})
-	if signErr != nil {
-		return fmt.Errorf("sign generated http request: %w", err)
+	if err != nil {
+		return "", fmt.Errorf("sign generated http request: %w", err)
 	}

 	genAuth, err := ParseAuthorization(req.Header.Get("Authorization"))
 	if err != nil {
-		return err
+		return "", err
 	}

 	if auth.Signature != genAuth.Signature {
-		return s3err.GetAPIError(s3err.ErrSignatureDoesNotMatch)
+		return "", s3err.GetSignatureDoesNotMatchErr(
+			auth.Access,
+			signMeta.StringToSign,
+			auth.Signature,
+			HexBytes(signMeta.StringToSign),
+			signMeta.CanonicalString,
+			HexBytes(signMeta.CanonicalString),
+		)
 	}

-	return nil
+	return signMeta.CanonicalString, nil
 }

 // AuthData is the parsed authorization data from the header
@@ -187,7 +130,7 @@ func ParseAuthorization(authorization string) (AuthData, error) {
 	}

 	if len(authParts) < 2 {
-		return a, s3err.GetAPIError(s3err.ErrInvalidAuthHeader)
+		return a, s3err.GetInvalidArgumentErr(s3err.InvalidArgAuthHeader, authorization)
 	}

 	algo := authParts[0]
@@ -196,7 +139,7 @@ func ParseAuthorization(authorization string) (AuthData, error) {
 		return a, s3err.GetAPIError(s3err.ErrUnsupportedAuthorizationMechanism)
 	}
 	if algo != "AWS4-HMAC-SHA256" {
-		return a, s3err.GetAPIError(s3err.ErrUnsupportedAuthorizationType)
+		return a, s3err.GetInvalidArgumentErr(s3err.InvalidArgAuthorizationType, algo)
 	}

 	kvData := authParts[1]
@@ -263,26 +206,26 @@ type CredentialsScope struct {
 }

 type CredsError interface {
-	MalformedCredential() s3err.APIError
-	IncorrectService(string) s3err.APIError
-	IncorrectTerminal(string) s3err.APIError
-	InvalidDateFormat(string) s3err.APIError
+	MalformedCredential(string) s3err.S3Error
+	IncorrectService(string, string) s3err.S3Error
+	IncorrectTerminal(string, string) s3err.S3Error
+	InvalidDateFormat(string, string) s3err.S3Error
 }

 func ParseCredentials(input string, errHandler CredsError) (*CredentialsScope, error) {
 	creds := strings.Split(input, "/")
 	if len(creds) != 5 {
-		return nil, errHandler.MalformedCredential()
+		return nil, errHandler.MalformedCredential(input)
 	}
 	if creds[3] != "s3" {
-		return nil, errHandler.IncorrectService(creds[3])
+		return nil, errHandler.IncorrectService(input, creds[3])
 	}
 	if creds[4] != "aws4_request" {
-		return nil, errHandler.IncorrectTerminal(creds[4])
+		return nil, errHandler.IncorrectTerminal(input, creds[4])
 	}
 	_, err := time.Parse(yyyymmdd, creds[1])
 	if err != nil {
-		return nil, errHandler.InvalidDateFormat(creds[1])
+		return nil, errHandler.InvalidDateFormat(input, creds[1])
 	}
 	return &CredentialsScope{
 		Access: creds[0],