Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): authorize read on copyobject/uploadpartcopy source (#3450)
Matheus Oliveirabb58176974b8
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.javaindex 42f72ac0b0..186af5d057 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java@@ -217,6 +217,76 @@ public class IamEnforcementFilter implements ContainerRequestFilter {}}+ /**+ * Authorizes a single (action, resource) pair for the caller identified by an+ * Authorization header, following the same identity resolution and bypass rules+ * as {@link #filter}. Callers use this for a secondary resource that never appears+ * in the request URL and so is invisible to {@link ResourceArnBuilder} - such as+ * the CopyObject/UploadPartCopy source object, which arrives only in the+ * {@code x-amz-copy-source} header.+ *+ * <p>Returns normally when the action is allowed, or when enforcement does not+ * apply to this request (enforcement disabled, no Authorization header, root or+ * unknown access key). Throws {@link AwsException} with the same AccessDenied+ * shape as {@link #filter} when the caller's policies deny the action.+ */+ public void authorizeAdditionalResource(String authorizationHeader, String action, String resource) {+ if (!config.services().iam().enforcementEnabled()) {+ return;+ }+ if (authorizationHeader == null) {+ return;+ }+ String akid = accountResolver.extractAccessKeyId(authorizationHeader);+ if (akid == null || "test".equals(akid)) {+ return;+ }+ if (extractCredentialScope(authorizationHeader) == null) {+ return;+ }++ String accountId = requestContext.getAccountId() == null+ ? accountResolver.resolve(authorizationHeader)+ : requestContext.getAccountId();++ List<List<String>> scpLevels = scpProvider.isResolvable()+ ? scpProvider.get().effectiveScpLevels(accountId) : null;++ boolean accountRootPrincipal = false;+ CallerContext caller = iamService.resolveCallerContext(akid);+ if (caller == null) {+ if (scpLevels == null || !akid.equals(accountId)) {+ return;+ }+ caller = CallerContext.of(List.of(ROOT_ALLOW_ALL));+ accountRootPrincipal = true;+ }+ if (scpLevels != null) {+ caller = caller.withScpLevels(scpLevels);+ }++ Map<String, List<String>> conditionContext = null;+ Optional<String> principalArn = accountRootPrincipal+ ? Optional.of("arn:aws:iam::" + accountId + ":root")+ : iamService.resolveCallerArn(akid);+ if (principalArn.isPresent()) {+ conditionContext = new HashMap<>();+ conditionContext.put("aws:PrincipalArn", List.of(principalArn.get()));+ }++ Decision decision = evaluator.evaluate(caller, null, action, resource, conditionContext);+ if (decision != Decision.DENY) {+ return;+ }+ LOG.infov("IAM enforcement DENY: akid={0} action={1} resource={2}", akid, action, resource);+ throw new AwsException("AccessDenied",+ "User: arn:aws:iam::" + accountId + ":user/" + akid+ + " is not authorized to perform: " + action+ + " on resource: \"" + resource + "\""+ + " because no identity-based policy allows the " + action + " action",+ 403);+ }+/*** Best-effort CloudTrail emission for S3 access denials. Without this hook,* denied requests get aborted before {@code S3Controller}'s try/catch seesdiff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.javaindex ef6c60ab50..c973e1b5bf 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.common.AccountResolver;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsNamespaces;+import io.github.hectorvent.floci.core.common.IamEnforcementFilter;import io.github.hectorvent.floci.core.common.XmlBuilder;import io.github.hectorvent.floci.core.common.XmlParser;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -94,6 +95,7 @@ public class S3Controller {private final AccountResolver accountResolver;private final RequestContext requestContext;private final IamService iamService;+ private final IamEnforcementFilter iamEnforcementFilter;@Injectpublic S3Controller(S3Service s3Service, S3SelectService s3SelectService,@@ -104,7 +106,8 @@ public class S3Controller {CloudTrailService cloudTrailService,AccountResolver accountResolver,RequestContext requestContext,- IamService iamService) {+ IamService iamService,+ IamEnforcementFilter iamEnforcementFilter) {this.s3Service = s3Service;this.s3SelectService = s3SelectService;this.regionResolver = regionResolver;@@ -115,6 +118,7 @@ public class S3Controller {this.accountResolver = accountResolver;this.requestContext = requestContext;this.iamService = iamService;+ this.iamEnforcementFilter = iamEnforcementFilter;}private void emitCloudTrailEvent(String eventName, String bucket, String key,@@ -2556,6 +2560,7 @@ public class S3Controller {String contentType, HttpHeaders httpHeaders) {CopySourceRef sourceObject = parseCopySource(copySource);String sourceBucket = sourceObject.bucket();+ authorizeCopySourceRead(httpHeaders, sourceBucket, sourceObject.objectKey());String copyContentEncoding = toPersistedContentEncoding(httpHeaders.getHeaderString("Content-Encoding"));String copyContentDisposition = httpHeaders.getHeaderString("Content-Disposition");String copyCacheControl = httpHeaders.getHeaderString("Cache-Control");@@ -2635,6 +2640,7 @@ public class S3Controller {String uploadId, int partNumber, HttpHeaders httpHeaders) {CopySourceRef sourceObject = parseCopySource(copySource);String sourceBucket = sourceObject.bucket();+ authorizeCopySourceRead(httpHeaders, sourceBucket, sourceObject.objectKey());String copySourceRange = httpHeaders.getHeaderString("x-amz-copy-source-range");String eTag = s3Service.uploadPartCopy(destBucket, destKey, uploadId, partNumber,sourceBucket, sourceObject.objectKey(), sourceObject.versionId(), copySourceRange,@@ -3699,6 +3705,19 @@ public class S3Controller {return Response.ok().build();}+ /**+ * Authorizes {@code s3:GetObject} on the CopyObject/UploadPartCopy source, which only ever appears+ * in the {@code x-amz-copy-source} header and is otherwise invisible to the request-level IAM filter+ * that authorizes the destination from the URL path. Real S3 requires both permissions: a caller+ * allowed to write to the destination bucket must not be able to exfiltrate an object it cannot read.+ * A no-op when IAM enforcement is disabled, matching {@link IamEnforcementFilter}'s own bypass rules.+ */+ private void authorizeCopySourceRead(HttpHeaders httpHeaders, String sourceBucket, String sourceKey) {+ String resource = S3PublicAccessEvaluator.objectArn(sourceBucket, sourceKey);+ iamEnforcementFilter.authorizeAdditionalResource(+ httpHeaders.getHeaderString("Authorization"), "s3:GetObject", resource);+ }+/*** Splits a raw {@code x-amz-copy-source} header into decoded source bucket, object key and optional* {@code versionId}. Shared by {@code CopyObject} and {@code UploadPartCopy}.diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3CopyObjectSourcePermissionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3CopyObjectSourcePermissionIntegrationTest.javanew file mode 100644index 0000000000..0d6d879d0d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3CopyObjectSourcePermissionIntegrationTest.java@@ -0,0 +1,192 @@+package io.github.hectorvent.floci.services.s3;++import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;++/**+ * Regression tests for issue #2333: CopyObject and UploadPartCopy only authorized+ * {@code s3:PutObject} on the destination and never checked {@code s3:GetObject} on+ * the copy source, which only ever appears in the {@code x-amz-copy-source} header.+ * A caller with write-only access to a bucket could therefore copy the contents of+ * any object it could not otherwise read, as long as it could guess the bucket/key.+ */+@QuarkusTest+@TestProfile(S3CopyObjectSourcePermissionIntegrationTest.IamEnforcementProfile.class)+class S3CopyObjectSourcePermissionIntegrationTest {++ private static final String REGION = "us-east-1";++ @Test+ void copyObjectIsDeniedWhenCallerCannotReadTheSource() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String sourceBucket = "copy-source-" + suffix;+ String destBucket = "copy-dest-" + suffix;+ String userName = "copy-write-only-" + suffix;++ createBucketAsRoot(sourceBucket);+ createBucketAsRoot(destBucket);+ putObjectAsRoot(sourceBucket, "private-secret.txt", "top secret payload");++ String accessKeyId = createUser(userName);+ putUserPolicy(userName, "DestWriteOnly", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"arn:aws:s3:::%1$s/*"}+ ]}""".formatted(destBucket));++ given()+ .header("Authorization", auth(accessKeyId, "s3"))+ .header("x-amz-copy-source", "/" + sourceBucket + "/private-secret.txt")+ .when()+ .put("/" + destBucket + "/exfiltrated.txt")+ .then()+ .statusCode(403)+ .body(containsString("<Code>AccessDenied</Code>"));+ }++ @Test+ void copyObjectSucceedsWhenCallerCanReadSourceAndWriteDestination() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String sourceBucket = "copy-source-ok-" + suffix;+ String destBucket = "copy-dest-ok-" + suffix;+ String userName = "copy-read-write-" + suffix;++ createBucketAsRoot(sourceBucket);+ createBucketAsRoot(destBucket);+ putObjectAsRoot(sourceBucket, "allowed.txt", "not secret");++ String accessKeyId = createUser(userName);+ putUserPolicy(userName, "SourceReadDestWrite", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:GetObject","Resource":"arn:aws:s3:::%1$s/*"},+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"arn:aws:s3:::%2$s/*"}+ ]}""".formatted(sourceBucket, destBucket));++ given()+ .header("Authorization", auth(accessKeyId, "s3"))+ .header("x-amz-copy-source", "/" + sourceBucket + "/allowed.txt")+ .when()+ .put("/" + destBucket + "/copied.txt")+ .then()+ .statusCode(200);+ }++ @Test+ void uploadPartCopyIsDeniedWhenCallerCannotReadTheSource() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String sourceBucket = "part-copy-source-" + suffix;+ String destBucket = "part-copy-dest-" + suffix;+ String userName = "part-copy-write-only-" + suffix;++ createBucketAsRoot(sourceBucket);+ createBucketAsRoot(destBucket);+ putObjectAsRoot(sourceBucket, "private-secret.txt", "top secret payload");++ String accessKeyId = createUser(userName);+ putUserPolicy(userName, "DestWriteOnly", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"arn:aws:s3:::%1$s/*"}+ ]}""".formatted(destBucket));++ String uploadId = initiateMultipartUploadAsRoot(destBucket, "exfiltrated.txt");++ given()+ .header("Authorization", auth(accessKeyId, "s3"))+ .header("x-amz-copy-source", "/" + sourceBucket + "/private-secret.txt")+ .queryParam("uploadId", uploadId)+ .queryParam("partNumber", 1)+ .when()+ .put("/" + destBucket + "/exfiltrated.txt")+ .then()+ .statusCode(403)+ .body(containsString("<Code>AccessDenied</Code>"));+ }++ private static void createBucketAsRoot(String bucket) {+ given()+ .header("Authorization", auth("test", "s3"))+ .when()+ .put("/" + bucket)+ .then()+ .statusCode(200);+ }++ private static void putObjectAsRoot(String bucket, String key, String body) {+ given()+ .header("Authorization", auth("test", "s3"))+ .contentType("text/plain")+ .body(body)+ .when()+ .put("/" + bucket + "/" + key)+ .then()+ .statusCode(200);+ }++ private static String initiateMultipartUploadAsRoot(String bucket, String key) {+ return given()+ .header("Authorization", auth("test", "s3"))+ .queryParam("uploads", "")+ .when()+ .post("/" + bucket + "/" + key)+ .then()+ .statusCode(200)+ .extract()+ .body()+ .xmlPath()+ .getString("InitiateMultipartUploadResult.UploadId");+ }++ private static String createUser(String userName) {+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserName", userName)+ .header("Authorization", auth("test", "iam"))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ return given()+ .formParam("Action", "CreateAccessKey")+ .formParam("UserName", userName)+ .header("Authorization", auth("test", "iam"))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");+ }++ private static void putUserPolicy(String userName, String policyName, String policyDocument) {+ given()+ .formParam("Action", "PutUserPolicy")+ .formParam("UserName", userName)+ .formParam("PolicyName", policyName)+ .formParam("PolicyDocument", policyDocument)+ .header("Authorization", auth("test", "iam"))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static String auth(String accessKeyId, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/20260629/" + REGION + "/" + service+ + "/aws4_request, SignedHeaders=host, Signature=abc";+ }++ public static final class IamEnforcementProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.iam.enforcement-enabled", "true");+ }+ }+}