Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): verify SigV4 signature on presigned URLs when enforce-auth is enabled (#1842)
JinHwanKim3fe836aa16d4
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3PresignedUrlSigV4VerificationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3PresignedUrlSigV4VerificationTest.javanew file mode 100644index 0000000000..a326be67aa--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3PresignedUrlSigV4VerificationTest.java@@ -0,0 +1,248 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.core.sync.RequestBody;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.iam.IamClient;+import software.amazon.awssdk.services.iam.model.CreateAccessKeyResponse;+import software.amazon.awssdk.services.s3.S3Client;+import software.amazon.awssdk.services.s3.S3Configuration;+import software.amazon.awssdk.services.s3.model.CreateBucketRequest;+import software.amazon.awssdk.services.s3.model.GetObjectRequest;+import software.amazon.awssdk.services.s3.model.PutObjectRequest;+import software.amazon.awssdk.services.s3.model.S3Exception;+import software.amazon.awssdk.services.s3.presigner.S3Presigner;+import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;++import java.net.URI;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.time.Duration;++import static org.assertj.core.api.Assertions.assertThat;++/**+ * Verifies presigned URL SigV4 verification against URLs produced by the AWS SDK for Java,+ * an independent signer. Tests are skipped when {@code floci.services.s3.enforce-auth} is not+ * enabled on the running Floci instance.+ */+@DisplayName("S3 Presigned URL SigV4 Verification")+class S3PresignedUrlSigV4VerificationTest {++ private static final String BUCKET = TestFixtures.uniqueName("sdk-presign-sigv4");+ private static final String KEY_A = "object-a.txt";+ private static final String KEY_B = "object-b.txt";+ private static final String BODY_A = "content-of-a";+ private static final String BODY_B = "content-of-b";++ private static final StaticCredentialsProvider CREDENTIALS =+ StaticCredentialsProvider.create(AwsBasicCredentials.create("test", "test"));++ private static S3Client s3;+ private static IamClient iam;+ private static boolean enforcementEnabled;++ @BeforeAll+ static void setup() {+ s3 = TestFixtures.s3Client();+ iam = TestFixtures.iamClient();++ s3.createBucket(CreateBucketRequest.builder().bucket(BUCKET).build());+ s3.putObject(PutObjectRequest.builder().bucket(BUCKET).key(KEY_A).build(),+ RequestBody.fromString(BODY_A));+ s3.putObject(PutObjectRequest.builder().bucket(BUCKET).key(KEY_B).build(),+ RequestBody.fromString(BODY_B));++ enforcementEnabled = probeEnforcementEnabled();+ }++ @AfterAll+ static void cleanup() {+ if (s3 != null) {+ s3.close();+ }+ if (iam != null) {+ iam.close();+ }+ }++ @Test+ @DisplayName("SDK presigned URL is accepted but not valid for another object")+ void sdkPresignedUrlIsAcceptedButNotValidForAnotherObject() throws Exception {+ assumeEnforcementEnabled();++ var urlA = presignGet(KEY_A);+ var urlB = presignGet(KEY_B);++ var a = httpGet(urlA);+ assertThat(a.statusCode()).isEqualTo(200);+ assertThat(a.body()).isEqualTo(BODY_A);++ var b = httpGet(urlB);+ assertThat(b.statusCode()).isEqualTo(200);+ assertThat(b.body()).isEqualTo(BODY_B);++ // Transplant: object A's raw path with object B's complete raw query+ var transplanted = TestFixtures.endpoint()+ + URI.create(urlA).getRawPath() + "?" + URI.create(urlB).getRawQuery();++ var t = httpGet(transplanted);+ assertThat(t.statusCode()).isEqualTo(403);+ assertThat(t.body()).contains("SignatureDoesNotMatch");+ }++ @Test+ @DisplayName("reordered query parameters still verify")+ void reorderedQueryParametersStillVerify() throws Exception {+ assumeEnforcementEnabled();++ var url = URI.create(presignGet(KEY_A));+ var pairs = url.getRawQuery().split("&");+ var reordered = new StringBuilder();+ for (var i = pairs.length - 1; i >= 0; i--) {+ reordered.append(pairs[i]);+ if (i > 0) {+ reordered.append("&");+ }+ }++ var r = httpGet(TestFixtures.endpoint() + url.getRawPath() + "?" + reordered);+ assertThat(r.statusCode()).isEqualTo(200);+ assertThat(r.body()).isEqualTo(BODY_A);+ }++ @Test+ @DisplayName("SDK presigned URL with special characters in query is accepted")+ void sdkPresignedUrlWithSpecialCharactersInQueryIsAccepted() throws Exception {+ assumeEnforcementEnabled();++ String url;+ try (var presigner = presigner()) {+ url = presigner.presignGetObject(GetObjectPresignRequest.builder()+ .signatureDuration(Duration.ofMinutes(5))+ .getObjectRequest(GetObjectRequest.builder()+ .bucket(BUCKET).key(KEY_A)+ .responseContentDisposition("attachment; filename=\"a b+c.txt\"")+ .build())+ .build()).url().toString();+ }++ var r = httpGet(url);+ assertThat(r.statusCode()).isEqualTo(200);+ assertThat(r.body()).isEqualTo(BODY_A);+ }++ @Test+ @DisplayName("expired presigned URL is rejected")+ void expiredPresignedUrlIsRejected() throws Exception {+ assumeEnforcementEnabled();++ var url = URI.create(presignGet(KEY_A));+ var expiredQuery = url.getRawQuery()+ .replaceFirst("X-Amz-Date=[^&]+", "X-Amz-Date=20200101T000000Z");++ var r = httpGet(TestFixtures.endpoint() + url.getRawPath() + "?" + expiredQuery);+ assertThat(r.statusCode()).isEqualTo(403);+ assertThat(r.body()).contains("AccessDenied");+ }++ @Test+ @DisplayName("presigned URL signed with IAM access key is accepted")+ void presignedUrlSignedWithIamAccessKeyIsAccepted() throws Exception {+ assumeEnforcementEnabled();++ var userName = TestFixtures.uniqueName("presign-user");+ iam.createUser(r -> r.userName(userName).path("/"));+ CreateAccessKeyResponse keyResponse = iam.createAccessKey(r -> r.userName(userName));+ var accessKeyId = keyResponse.accessKey().accessKeyId();+ var secretKey = keyResponse.accessKey().secretAccessKey();++ String url;+ try (var presigner = presigner(accessKeyId, secretKey)) {+ url = presigner.presignGetObject(GetObjectPresignRequest.builder()+ .signatureDuration(Duration.ofMinutes(5))+ .getObjectRequest(GetObjectRequest.builder().bucket(BUCKET).key(KEY_A).build())+ .build()).url().toString();+ }++ var r = httpGet(url);+ assertThat(r.statusCode()).isEqualTo(200);+ assertThat(r.body()).isEqualTo(BODY_A);+ }++ @Test+ @DisplayName("presigned URL with malformed credential is rejected")+ void presignedUrlWithMalformedCredentialIsRejected() throws Exception {+ assumeEnforcementEnabled();++ var url = URI.create(presignGet(KEY_A));+ var query = url.getRawQuery().replaceFirst("X-Amz-Credential=[^&]+", "X-Amz-Credential=test");++ var r = httpGet(TestFixtures.endpoint() + url.getRawPath() + "?" + query);+ assertThat(r.statusCode()).isEqualTo(403);+ assertThat(r.body()).contains("InvalidAccessKeyId");+ }++ private static boolean probeEnforcementEnabled() {+ var unknownS3 = S3Client.builder()+ .endpointOverride(TestFixtures.endpoint())+ .region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create("bad-key", "bad-secret")))+ .forcePathStyle(true)+ .build();+ try {+ unknownS3.getObject(GetObjectRequest.builder().bucket(BUCKET).key(KEY_A).build());+ return false;+ } catch (S3Exception e) {+ if (e.statusCode() == 403+ && "InvalidAccessKeyId".equals(e.awsErrorDetails().errorCode())) {+ return true;+ }+ throw e;+ } finally {+ unknownS3.close();+ }+ }++ private static void assumeEnforcementEnabled() {+ Assumptions.assumeTrue(enforcementEnabled,+ "S3 auth enforcement is not enabled - set floci.services.s3.enforce-auth=true to run these tests");+ }++ private static S3Presigner presigner() {+ return presigner("test", "test");+ }++ private static S3Presigner presigner(String accessKeyId, String secretKey) {+ return S3Presigner.builder()+ .endpointOverride(TestFixtures.endpoint())+ .region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create(accessKeyId, secretKey)))+ .serviceConfiguration(S3Configuration.builder().pathStyleAccessEnabled(true).build())+ .build();+ }++ private static String presignGet(String key) {+ try (var presigner = presigner()) {+ return presigner.presignGetObject(GetObjectPresignRequest.builder()+ .signatureDuration(Duration.ofMinutes(5))+ .getObjectRequest(GetObjectRequest.builder().bucket(BUCKET).key(key).build())+ .build()).url().toString();+ }+ }++ private static HttpResponse<String> httpGet(String url) throws Exception {+ return HttpClient.newHttpClient().send(+ HttpRequest.newBuilder(URI.create(url)).GET().build(),+ HttpResponse.BodyHandlers.ofString());+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilter.java b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilter.javaindex 38f83b5ad4..0c2ff2f0e0 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilter.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilter.java@@ -1,21 +1,44 @@package io.github.hectorvent.floci.services.s3;import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.services.iam.IamService;import jakarta.inject.Inject;import jakarta.ws.rs.container.ContainerRequestContext;import jakarta.ws.rs.container.ContainerRequestFilter;import jakarta.ws.rs.core.MediaType;+import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import jakarta.ws.rs.ext.Provider;+import org.jboss.logging.Logger;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.util.ArrayList;+import java.util.Comparator;+import java.util.List;+import java.util.stream.Collectors;@Providerpublic class PreSignedUrlFilter implements ContainerRequestFilter {+ private static final Logger LOG = Logger.getLogger(PreSignedUrlFilter.class);+ private static final String LEGACY_ACCESS_KEY_ID = "test";+ private static final String LEGACY_SECRET_KEY = "test";+private final PreSignedUrlGenerator presignGenerator;+ private final S3Service s3Service;+ private final IamService iamService;@Inject- public PreSignedUrlFilter(PreSignedUrlGenerator presignGenerator) {+ public PreSignedUrlFilter(PreSignedUrlGenerator presignGenerator,+ S3Service s3Service,+ IamService iamService) {this.presignGenerator = presignGenerator;+ this.s3Service = s3Service;+ this.iamService = iamService;}@Override@@ -28,6 +51,17 @@ public class PreSignedUrlFilter implements ContainerRequestFilter {return;}+ if (!"AWS4-HMAC-SHA256".equals(algorithm)) {+ requestContext.abortWith(+ errorResponse(+ 400,+ "AuthorizationQueryParametersError",+ "Unsupported X-Amz-Algorithm value: " + algorithm+ )+ );+ return;+ }+if (S3RequestAuthorizationParser.isMissingRequiredPresignedParameter(queryParams)) {requestContext.abortWith(errorResponse(S3RequestAuthorizationParser.AUTHORIZATION_QUERY_PARAMETERS_ERROR_STATUS,@@ -49,6 +83,17 @@ public class PreSignedUrlFilter implements ContainerRequestFilter {return;}+ if (expires < 1 || expires > 604800) {+ requestContext.abortWith(+ errorResponse(+ 400,+ "AuthorizationQueryParametersError",+ "X-Amz-Expires must be between 1 and 604800 seconds."+ )+ );+ return;+ }+// Check expirationif (presignGenerator.isExpired(amzDate, expires)) {requestContext.abortWith(errorResponse(403, "AccessDenied",@@ -56,8 +101,30 @@ public class PreSignedUrlFilter implements ContainerRequestFilter {return;}- // Optionally verify signature (if validateSignatures is enabled)- if (presignGenerator.shouldValidateSignatures()) {+ // Verify signature: SigV4 when enforce-auth is enabled, custom when validateSignatures is enabled+ if (s3Service.isAuthEnforced()) {+ String credential = queryParams.getFirst("X-Amz-Credential");+ String decodedCredential = URLDecoder.decode(credential, StandardCharsets.UTF_8);+ String[] credParts = decodedCredential.split("/");+ if (credParts.length < 5) {+ requestContext.abortWith(errorResponse(403, "InvalidAccessKeyId",+ "The AWS Access Key Id you provided does not exist in our records."));+ return;+ }++ String accessKeyId = credParts[0];+ String secretKey = resolveSecretKey(accessKeyId);+ if (secretKey == null) {+ requestContext.abortWith(errorResponse(403, "InvalidAccessKeyId",+ "The AWS Access Key Id you provided does not exist in our records."));+ return;+ }++ if (!verifySigV4Signature(requestContext, signature, secretKey)) {+ requestContext.abortWith(errorResponse(403, "SignatureDoesNotMatch",+ "The request signature we calculated does not match the signature you provided."));+ }+ } else if (presignGenerator.shouldValidateSignatures()) {String path = requestContext.getUriInfo().getPath();String[] parts = path.split("/", 3);if (parts.length < 3) {@@ -76,6 +143,159 @@ public class PreSignedUrlFilter implements ContainerRequestFilter {}}+ private boolean verifySigV4Signature(ContainerRequestContext requestContext,+ String signature, String secretKey) {+ try {+ var queryParams = requestContext.getUriInfo().getQueryParameters();+ String credential = queryParams.getFirst("X-Amz-Credential");+ String amzDate = queryParams.getFirst("X-Amz-Date");+ String signedHeaders = queryParams.getFirst("X-Amz-SignedHeaders");++ String decodedCredential = URLDecoder.decode(credential, StandardCharsets.UTF_8);+ String[] credParts = decodedCredential.split("/");+ if (credParts.length < 5) {+ return false;+ }+ String date = credParts[1];+ String region = credParts[2];+ String service = credParts[3];+ String credentialScope = date + "/" + region + "/" + service + "/aws4_request";++ // Build canonical headers from signed headers+ String host = requestContext.getUriInfo().getRequestUri().getHost();+ int port = requestContext.getUriInfo().getRequestUri().getPort();+ String authority = (port > 0 && port != 80 && port != 443) ? host + ":" + port : host;++ StringBuilder canonicalHeaders = new StringBuilder();+ for (String header : signedHeaders.split(";")) {+ if ("host".equals(header)) {+ canonicalHeaders.append("host:").append(authority).append("\n");+ } else {+ String canonicalValue = canonicalizeHeaderValue(requestContext.getHeaderString(header));+ canonicalHeaders.append(header).append(":").append(canonicalValue).append("\n");+ }+ }++ // Canonical request+ String path = requestContext.getUriInfo().getRequestUri().getRawPath();+ String canonicalQueryString = buildCanonicalQueryString(queryParams);+ String payloadHash = requestContext.getHeaderString("x-amz-content-sha256");+ if (payloadHash == null) {+ payloadHash = queryParams.getFirst("X-Amz-Content-Sha256");+ }+ if (payloadHash == null) {+ payloadHash = "UNSIGNED-PAYLOAD";+ }+ String canonicalRequest = requestContext.getMethod() + "\n"+ + path + "\n"+ + canonicalQueryString + "\n"+ + canonicalHeaders + "\n"+ + signedHeaders + "\n"+ + payloadHash;++ // String to sign+ String stringToSign = "AWS4-HMAC-SHA256\n"+ + amzDate + "\n"+ + credentialScope + "\n"+ + sha256Hex(canonicalRequest);++ // Derive signing key and compute expected signature+ byte[] signingKey = deriveSigningKey(secretKey, date, region, service);+ String expectedSignature = hexEncode(hmacSha256(signingKey, stringToSign));++ return MessageDigest.isEqual(+ expectedSignature.getBytes(StandardCharsets.UTF_8),+ signature.getBytes(StandardCharsets.UTF_8));++ } catch (Exception e) {+ LOG.debugv("Presigned SigV4 signature verification failed: {0}", e.getMessage());+ return false;+ }+ }++ private String resolveSecretKey(String accessKeyId) {+ if (LEGACY_ACCESS_KEY_ID.equals(accessKeyId)) {+ return LEGACY_SECRET_KEY;+ }+ if (iamService != null) {+ return iamService.findSecretKey(accessKeyId).orElse(null);+ }+ return null;+ }++ /**+ * Builds the SigV4 canonical query string from the framework's decoded query parameters:+ * URI-encode each name and value, exclude {@code X-Amz-Signature}, and sort by encoded+ * name and then by encoded value. Package-private for unit testing.+ */+ static String buildCanonicalQueryString(MultivaluedMap<String, String> decodedParams) {+ List<String[]> encodedParams = new ArrayList<>();+ for (var entry : decodedParams.entrySet()) {+ if ("X-Amz-Signature".equals(entry.getKey())) {+ continue;+ }+ String encodedName = awsUriEncode(entry.getKey());+ for (String value : entry.getValue()) {+ encodedParams.add(new String[]{encodedName, awsUriEncode(value)});+ }+ }+ encodedParams.sort(Comparator.comparing((String[] p) -> p[0]).thenComparing(p -> p[1]));+ return encodedParams.stream()+ .map(p -> p[0] + "=" + p[1])+ .collect(Collectors.joining("&"));+ }++ /**+ * Canonicalizes a signed header value per SigV4: trim, then collapse sequential spaces to+ * a single space. Package-private for unit testing.+ */+ static String canonicalizeHeaderValue(String value) {+ return value == null ? "" : value.trim().replaceAll(" +", " ");+ }++ static String awsUriEncode(String value) {+ StringBuilder encoded = new StringBuilder();+ for (byte b : value.getBytes(StandardCharsets.UTF_8)) {+ int c = b & 0xFF;+ if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')+ || (c >= '0' && c <= '9')+ || c == '-' || c == '_' || c == '.' || c == '~') {+ encoded.append((char) c);+ } else {+ encoded.append('%').append(String.format("%02X", c));+ }+ }+ return encoded.toString();+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region,+ String service) throws Exception {+ byte[] kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ byte[] kDate = hmacSha256(kSecret, date);+ byte[] kRegion = hmacSha256(kDate, region);+ byte[] kService = hmacSha256(kRegion, service);+ return hmacSha256(kService, "aws4_request");+ }++ private static byte[] hmacSha256(byte[] key, String data) throws Exception {+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ }++ private static String sha256Hex(String input) throws Exception {+ MessageDigest digest = MessageDigest.getInstance("SHA-256");+ return hexEncode(digest.digest(input.getBytes(StandardCharsets.UTF_8)));+ }++ private static String hexEncode(byte[] bytes) {+ StringBuilder sb = new StringBuilder(bytes.length * 2);+ for (byte b : bytes) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ }+private Response errorResponse(int status, String code, String message) {String xml = new XmlBuilder().raw("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilterTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilterTest.javanew file mode 100644index 0000000000..89fdeb380e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlFilterTest.java@@ -0,0 +1,90 @@+package io.github.hectorvent.floci.services.s3;++import jakarta.ws.rs.core.MultivaluedHashMap;+import jakarta.ws.rs.core.MultivaluedMap;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;++class PreSignedUrlFilterTest {++ private static MultivaluedMap<String, String> params() {+ return new MultivaluedHashMap<>();+ }++ @Test+ void sortsByEncodedNameRegardlessOfInputOrder() {+ MultivaluedMap<String, String> params = params();+ params.add("X-Amz-Date", "20260101T000000Z");+ params.add("X-Amz-Algorithm", "AWS4-HMAC-SHA256");+ params.add("X-Amz-Expires", "300");++ assertEquals(+ "X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20260101T000000Z&X-Amz-Expires=300",+ PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void encodesReservedCharactersAndSpacesPerSigV4() {+ MultivaluedMap<String, String> params = params();+ params.add("p", "a b+c/d%e");++ // space -> %20 (not +), '+' -> %2B, '/' -> %2F, '%' -> %25, uppercase hex+ assertEquals("p=a%20b%2Bc%2Fd%25e", PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void encodesParameterNameAsWellAsValue() {+ MultivaluedMap<String, String> params = params();+ params.add("a b", "c/d");++ assertEquals("a%20b=c%2Fd", PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void encodesNonAsciiValueByteByByte() {+ MultivaluedMap<String, String> params = params();+ params.add("p", "é€"); // é (C3 A9), € (E2 82 AC) in UTF-8++ assertEquals("p=%C3%A9%E2%82%AC", PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void representsEmptyValueAsNameEquals() {+ MultivaluedMap<String, String> params = params();+ params.add("acl", "");++ assertEquals("acl=", PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void sortsDuplicateNamesByEncodedValue() {+ MultivaluedMap<String, String> params = params();+ params.add("k", "b");+ params.add("k", "a");+ params.add("k", "10");++ // code-point order on encoded values: "10" < "a" < "b" ('1' < 'a' < 'b')+ assertEquals("k=10&k=a&k=b", PreSignedUrlFilter.buildCanonicalQueryString(params));+ }++ @Test+ void canonicalHeaderValueCollapsesSequentialSpaces() {+ assertEquals("a b", PreSignedUrlFilter.canonicalizeHeaderValue("a b"));+ assertEquals("a b", PreSignedUrlFilter.canonicalizeHeaderValue("a b"));+ assertEquals("a b", PreSignedUrlFilter.canonicalizeHeaderValue(" a b "));+ assertEquals("", PreSignedUrlFilter.canonicalizeHeaderValue(null));+ }++ @Test+ void excludesSignatureButKeepsEveryOtherParameter() {+ MultivaluedMap<String, String> params = params();+ params.add("X-Amz-Signature", "deadbeef");+ params.add("X-Amz-Date", "20260101T000000Z");+ params.add("X-Amz-Algorithm", "AWS4-HMAC-SHA256");++ assertEquals(+ "X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20260101T000000Z",+ PreSignedUrlFilter.buildCanonicalQueryString(params));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.javaindex b908b8dfac..1461475e7c 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java@@ -8,10 +8,17 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;+import java.net.URLEncoder;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;+import java.util.Arrays;import java.util.Map;+import java.util.stream.Collectors;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;@@ -156,15 +163,17 @@ class S3AuthEnforcementIntegrationTest {@Test@Order(8)void presignedRequestWithBadAccessKeyCannotUsePublicAccess() {+ String path = "/" + PUBLIC_BUCKET + "/" + PUBLIC_KEY;+ String sig = presignedSignature("GET", path, "bad-key", "bad-key", "3600");given().queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256").queryParam("X-Amz-Credential", credential("bad-key")).queryParam("X-Amz-Date", SIGNING_TIMESTAMP).queryParam("X-Amz-Expires", "3600").queryParam("X-Amz-SignedHeaders", "host")- .queryParam("X-Amz-Signature", "test")+ .queryParam("X-Amz-Signature", sig).when()- .get("/" + PUBLIC_BUCKET + "/" + PUBLIC_KEY)+ .get(path).then().statusCode(403).body(containsString("InvalidAccessKeyId"));@@ -198,15 +207,17 @@ class S3AuthEnforcementIntegrationTest {@Test@Order(11)void presignedRequestWithLocalAccessKeyCanReadPrivateObject() {+ String path = "/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY;+ String sig = presignedSignature("GET", path, "test", "test", "3600");given().queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256").queryParam("X-Amz-Credential", credential("test")).queryParam("X-Amz-Date", SIGNING_TIMESTAMP).queryParam("X-Amz-Expires", "3600").queryParam("X-Amz-SignedHeaders", "host")- .queryParam("X-Amz-Signature", "test")+ .queryParam("X-Amz-Signature", sig).when()- .get("/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY)+ .get(path).then().statusCode(200).body(equalTo("private body"));@@ -526,6 +537,121 @@ class S3AuthEnforcementIntegrationTest {.body(equalTo("versioned body"));}+ @Test+ @Order(22)+ void presignedRequestWithExplicitContentSha256IsAccepted() throws Exception {+ String path = "/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY;+ String contentHash = sha256Hex("private body");+ String sig = presignedSignature("GET", path, "test", "test", "3600", contentHash);+ given()+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "3600")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Content-Sha256", contentHash)+ .queryParam("X-Amz-Signature", sig)+ .when()+ .get(path)+ .then()+ .statusCode(200)+ .body(equalTo("private body"));+ }++ @Test+ @Order(23)+ void presignedRequestWithMismatchedContentSha256IsRejected() throws Exception {+ String path = "/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY;+ String contentHash = sha256Hex("private body");+ String wrongHash = sha256Hex("wrong body");+ String sig = presignedSignature("GET", path, "test", "test", "3600", contentHash);+ given()+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "3600")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Content-Sha256", wrongHash)+ .queryParam("X-Amz-Signature", sig)+ .when()+ .get(path)+ .then()+ .statusCode(403)+ .body(containsString("SignatureDoesNotMatch"));+ }++ @Test+ @Order(24)+ void presignedRequestWithTamperedSignatureIsRejected() {+ String path = "/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY;+ String signature = presignedSignature("GET", path, "test", "test", "3600");+ String tampered = signature.substring(0, signature.length() - 1)+ + (signature.endsWith("0") ? "1" : "0");+ given()+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "3600")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Signature", tampered)+ .when()+ .get(path)+ .then()+ .statusCode(403)+ .body(containsString("SignatureDoesNotMatch"));+ }++ @Test+ @Order(25)+ void presignedRequestWithExpiresExceedingMaxIsRejected() {+ given()+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "604801")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Signature", "dummy")+ .when()+ .get("/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY)+ .then()+ .statusCode(400)+ .body(containsString("AuthorizationQueryParametersError"));+ }++ @Test+ @Order(26)+ void presignedRequestWithExpiresZeroIsRejected() {+ given()+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "0")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Signature", "dummy")+ .when()+ .get("/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY)+ .then()+ .statusCode(400)+ .body(containsString("AuthorizationQueryParametersError"));+ }++ @Test+ @Order(27)+ void presignedRequestWithUnsupportedAlgorithmIsRejected() {+ given()+ .queryParam("X-Amz-Algorithm", "BOGUS-ALGORITHM")+ .queryParam("X-Amz-Credential", credential("test"))+ .queryParam("X-Amz-Date", SIGNING_TIMESTAMP)+ .queryParam("X-Amz-Expires", "3600")+ .queryParam("X-Amz-SignedHeaders", "host")+ .queryParam("X-Amz-Signature", "dummy")+ .when()+ .get("/" + PRIVATE_BUCKET + "/" + PRIVATE_KEY)+ .then()+ .statusCode(400)+ .body(containsString("AuthorizationQueryParametersError"));+ }+private static String publicReadPolicy(String bucket) {return """{@@ -557,6 +683,76 @@ class S3AuthEnforcementIntegrationTest {return accessKeyId + "/" + SIGNING_DATE + "/us-east-1/s3/aws4_request";}+ private static String presignedSignature(String method, String path,+ String accessKeyId, String secretKey, String expires) {+ return presignedSignature(method, path, accessKeyId, secretKey, expires, "UNSIGNED-PAYLOAD");+ }++ private static String presignedSignature(String method, String path,+ String accessKeyId, String secretKey,+ String expires, String payloadHash) {+ try {+ String credentialScope = SIGNING_DATE + "/us-east-1/s3/aws4_request";+ String encodedCredential = URLEncoder.encode(+ accessKeyId + "/" + credentialScope, StandardCharsets.UTF_8);++ // Build query string in sorted order (excluding Signature)+ String contentSha256Param = "UNSIGNED-PAYLOAD".equals(payloadHash)+ ? "" : "&X-Amz-Content-Sha256=" + payloadHash;+ String canonicalQueryString = "X-Amz-Algorithm=AWS4-HMAC-SHA256"+ + contentSha256Param+ + "&X-Amz-Credential=" + encodedCredential+ + "&X-Amz-Date=" + SIGNING_TIMESTAMP+ + "&X-Amz-Expires=" + expires+ + "&X-Amz-SignedHeaders=host";++ String canonicalRequest = method + "\n"+ + path + "\n"+ + canonicalQueryString + "\n"+ + "host:localhost:" + io.restassured.RestAssured.port + "\n\n"+ + "host\n"+ + payloadHash;++ String stringToSign = "AWS4-HMAC-SHA256\n"+ + SIGNING_TIMESTAMP + "\n"+ + credentialScope + "\n"+ + sha256Hex(canonicalRequest);++ byte[] signingKey = deriveSigningKey(secretKey, SIGNING_DATE, "us-east-1", "s3");+ return hexEncode(hmacSha256(signingKey, stringToSign));+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region,+ String service) throws Exception {+ byte[] kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ byte[] kDate = hmacSha256(kSecret, date);+ byte[] kRegion = hmacSha256(kDate, region);+ byte[] kService = hmacSha256(kRegion, service);+ return hmacSha256(kService, "aws4_request");+ }++ private static byte[] hmacSha256(byte[] key, String data) throws Exception {+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ }++ private static String sha256Hex(String input) throws Exception {+ MessageDigest digest = MessageDigest.getInstance("SHA-256");+ return hexEncode(digest.digest(input.getBytes(StandardCharsets.UTF_8)));+ }++ private static String hexEncode(byte[] bytes) {+ StringBuilder sb = new StringBuilder(bytes.length * 2);+ for (byte b : bytes) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ }+private static String websiteConfiguration() {return websiteConfiguration(null);}