Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): authorize the service that serves the request, not the one it was signed for (#4295)
Priamo Germosend2c0705ea9bc
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 67aafec330..cdabef03d5 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@@ -167,7 +167,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {// Normalise signing aliases (s3express → s3) before anything keyed by scope runs:// action rules, ARN building and condition keys all match the canonical name, so an// alias would resolve to no action and be allowed through without any policy check.- String credentialScope = catalog.canonicalCredentialScope(rawScope);+ String credentialScope = servingCredentialScope(catalog.canonicalCredentialScope(rawScope), ctx);String action = actionRegistry.resolve(credentialScope, ctx);if (action == null) {@@ -314,6 +314,50 @@ public class IamEnforcementFilter implements ContainerRequestFilter {return false;}+ /**+ * The scope of the service that will actually serve this request, which is not always the one+ * the caller signed for. Everything keyed by scope (the action, its ARNs, its condition keys)+ * has to describe the service that runs, or a policy naming that service never matches.+ *+ * <p>Only the claim decides this, never {@code X-Amz-Target} read directly: the target routes+ * a request solely under the conditions {@link ProtocolClaimer} applies, and reading it here+ * would let a header attached to, say, an S3 request move the authorization to another+ * service while S3 still served it.+ *+ * <p>{@link WireProtocol#AWS_QUERY} is out of scope for this method, not solved by it. A Query+ * claim carries the credential-scope service, which restates the caller whenever that service+ * serves Query at all; when it does not, {@code AwsQueryController} falls through to inferring+ * the service from the action name and can dispatch somewhere else entirely. Closing that needs+ * the controller's inference shared rather than duplicated here, and is tracked separately.+ */+ private String servingCredentialScope(String claimedScope, ContainerRequestContext ctx) {+ if (ctx.getProperty(AwsProtocolClaimFilter.CLAIM_PROPERTY) instanceof ProtocolClaim claim+ && claim.service() != null+ && claim.protocol() != WireProtocol.AWS_QUERY) {+ return iamServiceScope(claim.service(), claimedScope);+ }+ return claimedScope;+ }++ /** The descriptor's own scope, keeping {@code claimedScope} when the descriptor accepts it. */+ private String iamServiceScope(ServiceDescriptor descriptor, String claimedScope) {+ if (descriptor.credentialScopes().contains(claimedScope)) {+ return claimedScope;+ }+ // The service's own key, not just any scope it signs under: pricing accepts both+ // "pricing" and "api.pricing", and only the former is the namespace its policies name.+ // Sorting the rest keeps the choice stable, since credentialScopes is a Set.of whose+ // iteration order changes per JVM run.+ if (descriptor.credentialScopes().contains(descriptor.externalKey())) {+ return descriptor.externalKey();+ }+ return descriptor.credentialScopes().stream()+ .filter(scope -> scope.equals(catalog.canonicalCredentialScope(scope)))+ .sorted()+ .findFirst()+ .orElse(descriptor.externalKey());+ }+/** The same contexts with every object-tag key removed, keeping the principal and global keys. */private static List<Map<String, List<String>>> withoutObjectTags(List<Map<String, List<String>>> targetContexts) {diff --git a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.javaindex cbc7a391b3..d16f2700ba 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java@@ -26,6 +26,7 @@ import java.nio.charset.StandardCharsets;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.Set;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;@@ -34,6 +35,7 @@ import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;import static org.mockito.ArgumentMatchers.isNull;+import static org.mockito.Mockito.lenient;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.never;import static org.mockito.Mockito.times;@@ -142,6 +144,129 @@ class IamEnforcementFilterTest {verify(arnBuilder).buildResources("lambda", containerRequest, "us-east-1", "222233334444");}+ @Test+ void jsonProtocolActionComesFromTheTargetNotTheSignedScope() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ // Signed for lambda, but X-Amz-Target sends it to DynamoDB, which is where it will run.+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAUSER/20260629/us-east-1/lambda/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("AKIAUSER");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ when(containerRequest.getHeaderString("X-Amz-Target")).thenReturn("DynamoDB_20120810.PutItem");+ stubClaim(containerRequest, WireProtocol.AWS_JSON_1_0, dynamoDbDescriptor());+ when(iamService.resolveCallerContext("AKIAUSER"))+ .thenReturn(CallerContext.of(List.of("""+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Deny","Action":"dynamodb:*","Resource":"*"}]}""")));+ // Resolve for the serving service only. Left unstubbed the filter would leave through its+ // permissive unknown-action branch and the deny below would never be reached.+ when(actionRegistry.resolve("dynamodb", containerRequest)).thenReturn("dynamodb:PutItem");+ when(arnBuilder.buildResources("dynamodb", containerRequest, "us-east-1", "000000000000"))+ .thenReturn(List.of("*"));+ when(evaluator.evaluateResolvedResourcePolicy(any(), any(), any(), eq("dynamodb:PutItem"), any(), any()))+ .thenReturn(IamPolicyEvaluator.Decision.DENY);++ newFilter().filter(containerRequest);++ // Resolved as the serving service, and the deny on that service actually lands.+ verify(actionRegistry).resolve(eq("dynamodb"), eq(containerRequest));+ ArgumentCaptor<Response> denied = ArgumentCaptor.captor();+ verify(containerRequest).abortWith(denied.capture());+ assertEquals(403, denied.getValue().getStatus());+ }++ @Test+ void theServingScopeIsTheServicesOwnNamespaceNotJustAnySigningAlias() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAUSER/20260629/us-east-1/lambda/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("AKIAUSER");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ // Pricing signs under both "pricing" and "api.pricing"; only the former names its actions.+ stubClaim(containerRequest, WireProtocol.AWS_JSON_1_1, pricingDescriptor());+ when(iamService.resolveCallerContext("AKIAUSER")).thenReturn(CallerContext.of(List.of()));++ newFilter().filter(containerRequest);++ verify(actionRegistry).resolve(eq("pricing"), eq(containerRequest));+ }++ private static ServiceDescriptor pricingDescriptor() {+ return new ServiceDescriptor("pricing", "pricing", true, true, null, null, 5000L, null,+ ServiceProtocol.JSON, Set.of(ServiceProtocol.JSON), Set.of("AWSPriceListService."),+ Set.of("pricing", "api.pricing"), Set.of(), Set.of());+ }++ @Test+ void aScopeTheTargetsServiceAcceptsIsLeftAlone() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAUSER/20260629/us-east-1/dynamodb/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("AKIAUSER");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ when(containerRequest.getHeaderString("X-Amz-Target")).thenReturn("DynamoDB_20120810.PutItem");+ stubClaim(containerRequest, WireProtocol.AWS_JSON_1_0, dynamoDbDescriptor());+ when(iamService.resolveCallerContext("AKIAUSER")).thenReturn(CallerContext.of(List.of()));++ newFilter().filter(containerRequest);++ verify(actionRegistry).resolve(eq("dynamodb"), eq(containerRequest));+ }++ private static void stubClaim(ContainerRequestContext ctx, WireProtocol protocol,+ ServiceDescriptor descriptor) {+ when(ctx.getProperty(AwsProtocolClaimFilter.CLAIM_PROPERTY))+ .thenReturn(new ProtocolClaim(protocol, descriptor, null, null));+ }++ private static ServiceDescriptor dynamoDbDescriptor() {+ return new ServiceDescriptor("dynamodb", "dynamodb", true, true, "dynamodb", "memory", 0L, null,+ ServiceProtocol.JSON, Set.of(ServiceProtocol.JSON), Set.of("DynamoDB_20120810."),+ Set.of("dynamodb"), Set.of(), Set.of());+ }++ @Test+ void aTargetHeaderOnARequestThatIsNotDispatchedOnItDoesNotMoveTheAuthorization() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ // An S3 REST delete carrying a DynamoDB target. JAX-RS routes it to S3 whatever the header+ // says, so the header must not decide which service gets authorized.+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAUSER/20260629/us-east-1/s3/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("AKIAUSER");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ when(containerRequest.getHeaderString("X-Amz-Target")).thenReturn("DynamoDB_20120810.DescribeTable");+ // The target does resolve to DynamoDB; what must stop it is that this request was never+ // claimed for target dispatch, so the header is not what routes it.+ lenient().when(catalog.matchTarget("DynamoDB_20120810.DescribeTable")).thenReturn(Optional.of(+ new ServiceCatalog.TargetMatch(dynamoDbDescriptor(), "DynamoDB_20120810.", "DescribeTable")));+ when(containerRequest.getProperty(AwsProtocolClaimFilter.CLAIM_PROPERTY)).thenReturn(ProtocolClaim.rest());+ when(iamService.resolveCallerContext("AKIAUSER")).thenReturn(CallerContext.of(List.of()));++ newFilter().filter(containerRequest);++ verify(actionRegistry).resolve(eq("s3"), eq(containerRequest));+ }++ @Test+ void aQueryClaimNeverOverridesTheScopeItWasBuiltFrom() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ String auth = "AWS4-HMAC-SHA256 Credential=AKIAUSER/20260629/us-east-1/lambda/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("AKIAUSER");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ stubClaim(containerRequest, WireProtocol.AWS_QUERY, dynamoDbDescriptor());+ when(iamService.resolveCallerContext("AKIAUSER")).thenReturn(CallerContext.of(List.of()));++ newFilter().filter(containerRequest);++ verify(actionRegistry).resolve(eq("lambda"), eq(containerRequest));+ }+@Testvoid unknownAccessKeyIsRejectedInsteadOfBypassingEnforcement() {ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);