Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
new file mode 100644
index 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.java
index 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;
@Provider
public 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 expiration
if (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.java
new file mode 100644
index 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.java
index 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);
}