Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(auth,s3): resolve account context from X-Amz-Credential query param in presigned URLs (#1413)

alexjplantb2aea4207200
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AccountContextFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/AccountContextFilter.java
index 36b85efb5d..3e74164eea 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AccountContextFilter.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AccountContextFilter.java
@@ -10,7 +10,8 @@ import jakarta.ws.rs.ext.Provider;
/**
* Populates {@link RequestContext} with the account ID and region derived from
- * the incoming AWS Authorization header. Runs at AUTHENTICATION priority so that
+ * the incoming AWS Authorization header or, for presigned URL requests, the
+ * X-Amz-Credential query parameter. Runs at AUTHENTICATION priority so that
* downstream filters (e.g. IAM enforcement) can rely on the context being set.
*/
@Provider
@@ -34,7 +35,18 @@ public class AccountContextFilter implements ContainerRequestFilter {
@Override
public void filter(ContainerRequestContext ctx) {
String auth = ctx.getHeaderString("Authorization");
- requestContext.setAccountId(accountResolver.resolve(auth));
- requestContext.setRegion(regionResolver.resolveRegionFromAuth(auth));
+ if (auth != null && !auth.isEmpty()) {
+ requestContext.setAccountId(accountResolver.resolve(auth));
+ requestContext.setRegion(regionResolver.resolveRegionFromAuth(auth));
+ } else {
+ String credential = ctx.getUriInfo().getQueryParameters().getFirst("X-Amz-Credential");
+ if (credential != null && !credential.isEmpty()) {
+ requestContext.setAccountId(accountResolver.resolveFromPresignedCredential(credential));
+ requestContext.setRegion(regionResolver.resolveRegionFromPresignedCredential(credential));
+ } else {
+ requestContext.setAccountId(accountResolver.resolve(null));
+ requestContext.setRegion(regionResolver.resolveRegionFromAuth(null));
+ }
+ }
}
}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AccountResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/AccountResolver.java
index 86fd47cad5..c80777f7af 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AccountResolver.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AccountResolver.java
@@ -19,6 +19,10 @@ public class AccountResolver {
this.defaultAccountId = config.defaultAccountId();
}
+ public AccountResolver(String defaultAccountId) {
+ this.defaultAccountId = defaultAccountId;
+ }
+
/**
* Returns the account ID for the given Authorization header.
* When the access key ID is exactly 12 digits it is used directly as the account ID,
@@ -44,4 +48,25 @@ public class AccountResolver {
Matcher m = AKID_PATTERN.matcher(authorizationHeader);
return m.find() ? m.group(1) : null;
}
+
+ /**
+ * Resolves the account ID from an X-Amz-Credential value found in
+ * presigned URL query parameters.
+ * Format: accessKeyID/date/region/service/aws4_request
+ * When the access key ID is exactly 12 digits it is used directly
+ * as the account ID, matching LocalStack's multi-account convention.
+ * Any other key format or missing/malformed value falls back to
+ * the configured default account.
+ */
+ public String resolveFromPresignedCredential(String credentialValue) {
+ if (credentialValue == null || credentialValue.isEmpty()) {
+ return defaultAccountId;
+ }
+ String[] parts = credentialValue.split("/");
+ String akid = parts[0];
+ if (akid.matches("\\d{12}")) {
+ return akid;
+ }
+ return defaultAccountId;
+ }
}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/RegionResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/RegionResolver.java
index 35933043fd..49952f25ad 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/RegionResolver.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/RegionResolver.java
@@ -49,6 +49,24 @@ public class RegionResolver {
return matcher.find() ? matcher.group(1) : defaultRegion;
}
+ /**
+ * Resolves the region from an X-Amz-Credential value found in
+ * presigned URL query parameters.
+ * Format: accessKeyID/date/region/service/aws4_request
+ * Falls back to the configured default region if the credential value
+ * is null, empty, or does not contain enough segments.
+ */
+ public String resolveRegionFromPresignedCredential(String credentialValue) {
+ if (credentialValue == null || credentialValue.isEmpty()) {
+ return defaultRegion;
+ }
+ String[] parts = credentialValue.split("/");
+ if (parts.length >= 3) {
+ return parts[2];
+ }
+ return defaultRegion;
+ }
+
public String getDefaultRegion() {
return defaultRegion;
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java
index bd789bf546..e0b6cec8dd 100644
--- a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java
+++ b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java
@@ -1,7 +1,10 @@
package io.github.hectorvent.floci.services.s3;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.RequestContext;
import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.context.ContextNotActiveException;
+import jakarta.enterprise.inject.Instance;
import jakarta.inject.Inject;
import javax.crypto.Mac;
@@ -22,29 +25,54 @@ public class PreSignedUrlGenerator {
private final int defaultExpiry;
private final boolean validateSignatures;
private final String defaultRegion;
+ private final String defaultAccountId;
+
+ // Field-injected so the package-private test constructors remain valid
+ @Inject
+ Instance<RequestContext> requestContextInstance;
@Inject
public PreSignedUrlGenerator(EmulatorConfig config) {
this(config.auth().presignSecret(),
config.services().s3().defaultPresignExpirySeconds(),
config.auth().validateSignatures(),
- config.defaultRegion());
+ config.defaultRegion(),
+ config.defaultAccountId());
}
/** Package-private constructor for testing. */
PreSignedUrlGenerator(String secret, int defaultExpiry) {
- this(secret, defaultExpiry, false, "us-east-1");
+ this(secret, defaultExpiry, false, "us-east-1", "000000000000");
}
PreSignedUrlGenerator(String secret, int defaultExpiry, boolean validateSignatures) {
- this(secret, defaultExpiry, validateSignatures, "us-east-1");
+ this(secret, defaultExpiry, validateSignatures, "us-east-1", "000000000000");
}
PreSignedUrlGenerator(String secret, int defaultExpiry, boolean validateSignatures, String defaultRegion) {
+ this(secret, defaultExpiry, validateSignatures, defaultRegion, "000000000000");
+ }
+
+ PreSignedUrlGenerator(String secret, int defaultExpiry, boolean validateSignatures, String defaultRegion, String defaultAccountId) {
this.secret = secret;
this.defaultExpiry = defaultExpiry;
this.validateSignatures = validateSignatures;
this.defaultRegion = defaultRegion;
+ this.defaultAccountId = defaultAccountId;
+ }
+
+ private String resolveAccessKeyId() {
+ if (requestContextInstance != null) {
+ try {
+ String accountId = requestContextInstance.get().getAccountId();
+ if (accountId != null) {
+ return accountId;
+ }
+ } catch (ContextNotActiveException ignored) {
+ // outside request scope — fall through to default
+ }
+ }
+ return defaultAccountId;
}
public boolean shouldValidateSignatures() {
@@ -55,7 +83,7 @@ public class PreSignedUrlGenerator {
String method, int expiresSeconds) {
int expiry = expiresSeconds > 0 ? expiresSeconds : defaultExpiry;
String amzDate = AMZ_DATE_FORMAT.format(Instant.now());
- String credential = "AKIAIOSFODNN7EXAMPLE/" + amzDate.substring(0, 8) + "/" + defaultRegion + "/s3/aws4_request";
+ String credential = resolveAccessKeyId() + "/" + amzDate.substring(0, 8) + "/" + defaultRegion + "/s3/aws4_request";
String signature = computeSignature(method, bucket, key, amzDate, expiry);
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AccountContextFilterTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AccountContextFilterTest.java
new file mode 100644
index 0000000000..b973a21099
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/core/common/AccountContextFilterTest.java
@@ -0,0 +1,102 @@
+package io.github.hectorvent.floci.core.common;
+
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriInfo;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class AccountContextFilterTest {
+
+ private static final String DEFAULT_ACCOUNT = "000000000000";
+ private static final String DEFAULT_REGION = "us-east-1";
+
+ private AccountResolver accountResolver;
+ private RegionResolver regionResolver;
+ private RequestContext requestContext;
+ private AccountContextFilter filter;
+
+ @BeforeEach
+ void setUp() {
+ accountResolver = new AccountResolver(DEFAULT_ACCOUNT);
+ regionResolver = new RegionResolver(DEFAULT_REGION, DEFAULT_ACCOUNT);
+ requestContext = new RequestContext();
+ filter = new AccountContextFilter(accountResolver, regionResolver, requestContext);
+ }
+
+ @Test
+ void resolvesFromAuthHeaderWhenPresent() {
+ ContainerRequestContext ctx = mockContext(
+ "AWS4-HMAC-SHA256 Credential=000000000001/20260617/us-west-2/s3/aws4_request, SignedHeaders=host, Signature=abc",
+ null
+ );
+ filter.filter(ctx);
+ assertEquals("000000000001", requestContext.getAccountId());
+ assertEquals("us-west-2", requestContext.getRegion());
+ }
+
+ @Test
+ void resolvesFromPresignedCredentialWhenNoAuthHeader() {
+ ContainerRequestContext ctx = mockContext(null,
+ "000000000002/20260617/eu-west-1/s3/aws4_request");
+ filter.filter(ctx);
+ assertEquals("000000000002", requestContext.getAccountId());
+ assertEquals("eu-west-1", requestContext.getRegion());
+ }
+
+ @Test
+ void authHeaderTakesPrecedenceOverPresignedCredential() {
+ ContainerRequestContext ctx = mockContext(
+ "AWS4-HMAC-SHA256 Credential=000000000001/20260617/us-west-2/s3/aws4_request, SignedHeaders=host, Signature=abc",
+ "000000000002/20260617/eu-west-1/s3/aws4_request"
+ );
+ filter.filter(ctx);
+ assertEquals("000000000001", requestContext.getAccountId());
+ assertEquals("us-west-2", requestContext.getRegion());
+ }
+
+ @Test
+ void fallsBackToDefaultsWhenNoAuthInfo() {
+ ContainerRequestContext ctx = mockContext(null, null);
+ filter.filter(ctx);
+ assertEquals(DEFAULT_ACCOUNT, requestContext.getAccountId());
+ assertEquals(DEFAULT_REGION, requestContext.getRegion());
+ }
+
+ @Test
+ void emptyAuthHeaderFallsBackToPresignedCredential() {
+ ContainerRequestContext ctx = mockContext("",
+ "000000000002/20260617/eu-west-1/s3/aws4_request");
+ filter.filter(ctx);
+ assertEquals("000000000002", requestContext.getAccountId());
+ assertEquals("eu-west-1", requestContext.getRegion());
+ }
+
+ @Test
+ void emptyPresignedCredentialFallsBackToDefaults() {
+ ContainerRequestContext ctx = mockContext("", "");
+ filter.filter(ctx);
+ assertEquals(DEFAULT_ACCOUNT, requestContext.getAccountId());
+ assertEquals(DEFAULT_REGION, requestContext.getRegion());
+ }
+
+ private ContainerRequestContext mockContext(String authHeader, String xAmzCredential) {
+ ContainerRequestContext ctx = mock(ContainerRequestContext.class);
+ when(ctx.getHeaderString("Authorization")).thenReturn(authHeader);
+
+ UriInfo uriInfo = mock(UriInfo.class);
+ MultivaluedMap<String, String> queryParams = new MultivaluedHashMap<>();
+ if (xAmzCredential != null) {
+ queryParams.add("X-Amz-Credential", xAmzCredential);
+ }
+ when(uriInfo.getQueryParameters()).thenReturn(queryParams);
+ when(ctx.getUriInfo()).thenReturn(uriInfo);
+
+ return ctx;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AccountResolverTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AccountResolverTest.java
new file mode 100644
index 0000000000..e4b21d50f0
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/core/common/AccountResolverTest.java
@@ -0,0 +1,59 @@
+package io.github.hectorvent.floci.core.common;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class AccountResolverTest {
+
+ private static final String DEFAULT_ACCOUNT = "000000000000";
+ private final AccountResolver resolver = new AccountResolver(DEFAULT_ACCOUNT);
+
+ // --- resolve(String authorizationHeader) tests ---
+
+ @Test
+ void resolvesFrom12DigitAkidInAuthHeader() {
+ String auth = "AWS4-HMAC-SHA256 Credential=000000000001/20260617/us-east-1/s3/aws4_request, SignedHeaders=host, Signature=abc";
+ assertEquals("000000000001", resolver.resolve(auth));
+ }
+
+ @Test
+ void fallsBackToDefaultForNon12DigitAkidInAuthHeader() {
+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20260617/us-east-1/s3/aws4_request, SignedHeaders=host, Signature=abc";
+ assertEquals(DEFAULT_ACCOUNT, resolver.resolve(auth));
+ }
+
+ @Test
+ void fallsBackToDefaultWhenNullAuthHeader() {
+ assertEquals(DEFAULT_ACCOUNT, resolver.resolve(null));
+ }
+
+ @Test
+ void fallsBackToDefaultWhenEmptyAuthHeader() {
+ assertEquals(DEFAULT_ACCOUNT, resolver.resolve(""));
+ }
+
+ // --- resolveFromPresignedCredential(String credentialValue) tests ---
+
+ @Test
+ void resolvesFromPresigned12DigitAkid() {
+ assertEquals("000000000001",
+ resolver.resolveFromPresignedCredential("000000000001/20260617/us-east-1/s3/aws4_request"));
+ }
+
+ @Test
+ void fallsBackToDefaultForPresignedNon12DigitAkid() {
+ assertEquals(DEFAULT_ACCOUNT,
+ resolver.resolveFromPresignedCredential("AKIAIOSFODNN7EXAMPLE/20260617/us-east-1/s3/aws4_request"));
+ }
+
+ @Test
+ void fallsBackToDefaultWhenPresignedCredentialNull() {
+ assertEquals(DEFAULT_ACCOUNT, resolver.resolveFromPresignedCredential(null));
+ }
+
+ @Test
+ void fallsBackToDefaultWhenPresignedCredentialEmpty() {
+ assertEquals(DEFAULT_ACCOUNT, resolver.resolveFromPresignedCredential(""));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/RegionResolverTest.java b/src/test/java/io/github/hectorvent/floci/core/common/RegionResolverTest.java
index d907a87c66..f418f1d085 100644
--- a/src/test/java/io/github/hectorvent/floci/core/common/RegionResolverTest.java
+++ b/src/test/java/io/github/hectorvent/floci/core/common/RegionResolverTest.java
@@ -78,6 +78,35 @@ class RegionResolverTest {
assertEquals("ap-southeast-1", custom.resolveRegion(null));
}
+ // --- resolveRegionFromPresignedCredential(String credentialValue) tests ---
+
+ @Test
+ void resolveRegionFromPresignedCredential_validCredential_returnsRegion() {
+ assertEquals("us-west-2",
+ resolver.resolveRegionFromPresignedCredential("000000000001/20260617/us-west-2/s3/aws4_request"));
+ }
+
+ @Test
+ void resolveRegionFromPresignedCredential_differentRegion() {
+ assertEquals("eu-central-1",
+ resolver.resolveRegionFromPresignedCredential("AKID/20260617/eu-central-1/s3/aws4_request"));
+ }
+
+ @Test
+ void resolveRegionFromPresignedCredential_null_returnsDefault() {
+ assertEquals("us-east-1", resolver.resolveRegionFromPresignedCredential(null));
+ }
+
+ @Test
+ void resolveRegionFromPresignedCredential_empty_returnsDefault() {
+ assertEquals("us-east-1", resolver.resolveRegionFromPresignedCredential(""));
+ }
+
+ @Test
+ void resolveRegionFromPresignedCredential_malformedTooFewParts_returnsDefault() {
+ assertEquals("us-east-1", resolver.resolveRegionFromPresignedCredential("only-two/parts"));
+ }
+
private static HttpHeaders stubHeaders(String authorizationValue) {
return new HttpHeaders() {
@Override public List<String> getRequestHeader(String name) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlAccountResolutionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlAccountResolutionIntegrationTest.java
new file mode 100644
index 0000000000..1a525711ed
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlAccountResolutionIntegrationTest.java
@@ -0,0 +1,171 @@
+package io.github.hectorvent.floci.services.s3;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.MethodOrderer;
+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.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+
+/**
+ * End-to-end integration test verifying that presigned URL requests carrying
+ * credentials only in {@code X-Amz-Credential} (no Authorization header)
+ * correctly resolve the account ID and route to the right account's bucket.
+ *
+ * <p>This is the scenario that was previously broken: the AccountContextFilter
+ * now falls back to X-Amz-Credential query param when Authorization is absent,
+ * allowing presigned URL requests to be routed to the correct account's storage.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class PreSignedUrlAccountResolutionIntegrationTest {
+
+ private static final String BUCKET = "presigned-account-resolution-bucket";
+ private static final String KEY = "account-resolved-object.txt";
+ private static final String BODY = "content-for-account-000000000001";
+
+ // 12-digit numeric AKID → treated as account ID
+ private static final String ACCOUNT_1 = "000000000001";
+ private static final String ACCOUNT_2 = "000000000002";
+
+ private static final String AUTH_ACCOUNT_1 =
+ "AWS4-HMAC-SHA256 Credential=" + ACCOUNT_1 + "/20260617/us-east-1/s3/aws4_request";
+ private static final String AUTH_ACCOUNT_2 =
+ "AWS4-HMAC-SHA256 Credential=" + ACCOUNT_2 + "/20260617/us-east-1/s3/aws4_request";
+
+ private static final DateTimeFormatter AMZ_DATE_FMT =
+ DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);
+
+ @Test
+ @Order(1)
+ void createBucketAndPutObjectUnderAccount1() {
+ // Create bucket under account 000000000001
+ given()
+ .header("Authorization", AUTH_ACCOUNT_1)
+ .when()
+ .put("/" + BUCKET)
+ .then()
+ .statusCode(200);
+
+ // Put object under account 000000000001
+ given()
+ .header("Authorization", AUTH_ACCOUNT_1)
+ .body(BODY)
+ .contentType("text/plain")
+ .when()
+ .put("/" + BUCKET + "/" + KEY)
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(2)
+ void presignedUrlWithXAmzCredentialResolvesCorrectAccount() {
+ // Craft a presigned GET URL that carries credentials ONLY in X-Amz-Credential
+ // query parameter (no Authorization header). This is the scenario that was
+ // previously broken: AccountContextFilter must fall back to X-Amz-Credential
+ // when Authorization is absent.
+ String amzDate = AMZ_DATE_FMT.format(Instant.now());
+ String dateStamp = amzDate.substring(0, 8);
+ String credential = ACCOUNT_1 + "/" + dateStamp + "/us-east-1/s3/aws4_request";
+
+ String path = "/" + BUCKET + "/" + KEY
+ + "?X-Amz-Algorithm=AWS4-HMAC-SHA256"
+ + "&X-Amz-Credential=" + URLEncoder.encode(credential, StandardCharsets.UTF_8)
+ + "&X-Amz-Date=" + amzDate
+ + "&X-Amz-Expires=3600"
+ + "&X-Amz-SignedHeaders=host"
+ + "&X-Amz-Signature=fakesig";
+
+ given()
+ .urlEncodingEnabled(false)
+ .when()
+ .get(path)
+ .then()
+ .statusCode(200)
+ .body(equalTo(BODY));
+ }
+
+ @Test
+ @Order(3)
+ void presignedUrlWithWrongAccountCannotAccessOtherAccountsBucket() {
+ // Verify isolation: when account 000000000002 tries to access a bucket
+ // that belongs to account 000000000001, it should get NoSuchBucket (404)
+ // because that bucket doesn't exist under account 2.
+ String amzDate = AMZ_DATE_FMT.format(Instant.now());
+ String dateStamp = amzDate.substring(0, 8);
+ String credential = ACCOUNT_2 + "/" + dateStamp + "/us-east-1/s3/aws4_request";
+
+ String path = "/" + BUCKET + "/" + KEY
+ + "?X-Amz-Algorithm=AWS4-HMAC-SHA256"
+ + "&X-Amz-Credential=" + URLEncoder.encode(credential, StandardCharsets.UTF_8)
+ + "&X-Amz-Date=" + amzDate
+ + "&X-Amz-Expires=3600"
+ + "&X-Amz-SignedHeaders=host"
+ + "&X-Amz-Signature=fakesig";
+
+ given()
+ .urlEncodingEnabled(false)
+ .when()
+ .get(path)
+ .then()
+ .statusCode(404)
+ .body(containsString("NoSuchBucket"));
+ }
+
+ @Test
+ @Order(4)
+ void presignedUrlWithXAmzCredentialDoesNotFallBackToDefault() {
+ // Verify that a presigned URL with X-Amz-Credential does NOT fall back to
+ // the default account when the credential specifies a real 12-digit account.
+ // This re-validates after the wrong-account isolation test to confirm no
+ // state pollution occurred.
+ String amzDate = AMZ_DATE_FMT.format(Instant.now());
+ String dateStamp = amzDate.substring(0, 8);
+ String credential = ACCOUNT_1 + "/" + dateStamp + "/us-east-1/s3/aws4_request";
+
+ // A properly-credentialed presigned URL succeeds (re-validate after previous test)
+ String path = "/" + BUCKET + "/" + KEY
+ + "?X-Amz-Algorithm=AWS4-HMAC-SHA256"
+ + "&X-Amz-Credential=" + URLEncoder.encode(credential, StandardCharsets.UTF_8)
+ + "&X-Amz-Date=" + amzDate
+ + "&X-Amz-Expires=3600"
+ + "&X-Amz-SignedHeaders=host"
+ + "&X-Amz-Signature=fakesig";
+
+ given()
+ .urlEncodingEnabled(false)
+ .when()
+ .get(path)
+ .then()
+ .statusCode(200)
+ .body(equalTo(BODY));
+ }
+
+ @Test
+ @Order(99)
+ void cleanUp() {
+ given()
+ .header("Authorization", AUTH_ACCOUNT_1)
+ .when()
+ .delete("/" + BUCKET + "/" + KEY)
+ .then()
+ .statusCode(204);
+
+ given()
+ .header("Authorization", AUTH_ACCOUNT_1)
+ .when()
+ .delete("/" + BUCKET)
+ .then()
+ .statusCode(204);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlIntegrationTest.java
index 39995a87a9..b0f37950ba 100644
--- a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlIntegrationTest.java
@@ -8,6 +8,8 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import java.net.URI;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;
@@ -70,6 +72,19 @@ class PreSignedUrlIntegrationTest {
assertTrue(url.contains("X-Amz-Expires=300"));
assertTrue(url.contains("X-Amz-SignedHeaders=host"));
assertTrue(url.contains("X-Amz-Signature="));
+
+ // Verify X-Amz-Credential uses request-scoped account ID, not the hardcoded placeholder
+ assertFalse(url.contains("AKIAIOSFODNN7EXAMPLE"),
+ "X-Amz-Credential must not contain hardcoded AKIAIOSFODNN7EXAMPLE");
+
+ int credStart = url.indexOf("X-Amz-Credential=");
+ int credEnd = url.indexOf("&", credStart);
+ String encodedCredential = credEnd > 0
+ ? url.substring(credStart + "X-Amz-Credential=".length(), credEnd)
+ : url.substring(credStart + "X-Amz-Credential=".length());
+ String credential = URLDecoder.decode(encodedCredential, StandardCharsets.UTF_8);
+ assertTrue(credential.startsWith("000000000000/"),
+ "X-Amz-Credential should start with 12-digit account ID, got: " + credential);
}
@Test