Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(stepfunctions): honor explicit Lambda task qualifiers (#6563)

Andre Kurait74a932bc5067
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.md
index a0d1d82dfc..9e4252f2bd 100644
--- a/docs/services/step-functions.md
+++ b/docs/services/step-functions.md
@@ -51,8 +51,10 @@ Omitting the filter returns all statuses. Invalid filter values or types return
`ValidationException`. Map Run execution listing and `PENDING_REDRIVE` filtering are not
supported; `PENDING_REDRIVE` returns `ValidationException` even when a `mapRunArn` is supplied.
-Lambda task invocation retains the alias or version from `FunctionName` or a
-direct function ARN when acquiring execution capacity. A READY provisioned
+Lambda task invocation retains the alias or version from `FunctionName`, the
+optimized integration's `Qualifier` parameter, or a direct function ARN when
+acquiring execution capacity. Embedded and explicit qualifiers must agree.
+A READY provisioned
concurrency pool for that qualifier can serve the task; resolving an alias to
its version does not discard its pool identity. Unqualified invocation retains
the normal on-demand path, and existing authorization checks still precede
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
index 124c3e648e..2ffa86d776 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
@@ -1288,7 +1288,8 @@ public class AslExecutor {
AwsArnUtils.Arn stateMachineArn = AwsArnUtils.parse(sm.getStateMachineArn());
LambdaArnUtils.ResolvedFunctionRef ref;
try {
- ref = LambdaArnUtils.resolve(functionRef);
+ ref = LambdaArnUtils.resolveWithQualifier(functionRef,
+ optimizedLambdaInvoke ? input.path("Qualifier").asText(null) : null);
} catch (AwsException e) {
throw new FailStateException("Lambda." + e.getErrorCode(), e.getMessage());
}
@@ -1303,6 +1304,7 @@ public class AslExecutor {
String region = ref.region() != null ? ref.region() : stateMachineArn.region();
String accountId = ref.account() == null || ref.account().equals(stateMachineArn.accountId())
? null : ref.account();
+ String invokedQualifier = ref.qualifier();
// The task invokes the function as its role: the execution role, or the role its
// Credentials name once the execution role has assumed it. The role's policies or the
// function's have to allow the call, and both when the function is in another account.
@@ -1318,12 +1320,14 @@ public class AslExecutor {
}
String functionArn = LambdaArnUtils.functionArn(functionRef, stateMachineArn.partition(), region,
stateMachineArn.accountId());
+ if (invokedQualifier != null && extractLambdaQualifier(functionRef) == null) {
+ functionArn += ":" + invokedQualifier;
+ }
Optional<String> refusal = lambdaTaskAuthorizer.refusal(invokingRoleArn, functionArn);
if (refusal.isPresent()) {
throw new FailStateException("Lambda.AccessDeniedException", refusal.get());
}
}
- String invokedQualifier = extractLambdaQualifier(functionRef);
LambdaFunction fn = resolveLambdaFunction(accountId, region, functionName, invokedQualifier);
if (fn == null) {
// A missing function is a task failure on AWS, so it must stay reachable for
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java
index cdfdbc12ac..2e82ade836 100644
--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java
@@ -18,6 +18,8 @@ import io.vertx.mutiny.core.Vertx;
import jakarta.inject.Inject;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
import java.util.ArrayList;
import java.util.List;
@@ -31,6 +33,7 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
@@ -288,6 +291,43 @@ class AslExecutorLambdaArnTargetTest {
verify(authorizer).assumeRefusal(ROLE_ARN, TASK_ROLE_ARN, STATE_MACHINE_ARN);
}
+ @ParameterizedTest
+ @ValueSource(strings = {"worker", "111111111111:function:worker",
+ "arn:aws:lambda:us-east-2:111111111111:function:worker"})
+ void anExplicitQualifierIsAuthorizedBeforeResolvingOrInvoking(String reference) {
+ LambdaTaskAuthorizer authorizer = enforcing();
+ when(authorizer.refusal(anyString(), anyString())).thenReturn(Optional.of("refused"));
+
+ Execution execution = run("""
+ {"StartAt":"Call","States":{"Call":{"Type":"Task",
+ "Resource":"arn:aws:states:::lambda:invoke",
+ "Parameters":{"FunctionName":"%s","Qualifier":"live"},"End":true}}}
+ """.formatted(reference));
+
+ assertEquals("FAILED", execution.getStatus());
+ assertEquals("Lambda.AccessDeniedException", execution.getError());
+ String account = reference.equals(FUNCTION_NAME) ? ACCOUNT : OTHER_ACCOUNT;
+ verify(authorizer).refusal(ROLE_ARN, functionArn(account, REGION) + ":live");
+ verifyNoInteractions(functionStore, lambdaExecutor);
+ }
+
+ @Test
+ void anExplicitQualifierDoesNotChangeFunctionNameValidation() {
+ LambdaTaskAuthorizer authorizer = enforcing();
+ when(authorizer.refusal(anyString(), anyString())).thenReturn(Optional.of("refused"));
+ String qualifier = "q".repeat(128);
+
+ Execution execution = run("""
+ {"StartAt":"Call","States":{"Call":{"Type":"Task",
+ "Resource":"arn:aws:states:::lambda:invoke",
+ "Parameters":{"FunctionName":"%s","Qualifier":"%s"},"End":true}}}
+ """.formatted(functionArn(ACCOUNT, REGION), qualifier));
+
+ assertEquals("Lambda.AccessDeniedException", execution.getError());
+ verify(authorizer).refusal(ROLE_ARN, functionArn(ACCOUNT, REGION) + ":" + qualifier);
+ verifyNoInteractions(functionStore, lambdaExecutor);
+ }
+
private LambdaTaskAuthorizer enforcing() {
EmulatorConfig enforcing = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);
when(enforcing.services().iam().enforcementEnabled()).thenReturn(true);
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java
index f33880f80d..ffdb2a223c 100644
--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java
@@ -18,6 +18,9 @@ import io.vertx.mutiny.core.Vertx;
import jakarta.inject.Inject;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
import java.util.ArrayList;
import java.util.List;
@@ -31,6 +34,7 @@ import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
@@ -291,6 +295,58 @@ class AslExecutorLambdaInvokeResultTest {
eq(InvocationType.RequestResponse), eq(0), eq("live"));
}
+ @ParameterizedTest
+ @ValueSource(strings = {"echo-lambda", "000000000000:function:echo-lambda",
+ "arn:aws:lambda:us-east-2:000000000000:function:echo-lambda"})
+ void optimizedInvokeUsesAnExplicitAlias(String reference) throws Exception {
+ stubVersion("2", "V2");
+ LambdaAlias alias = new LambdaAlias();
+ alias.setName("live");
+ alias.setFunctionName(FUNCTION_NAME);
+ alias.setFunctionVersion("2");
+ when(aliasStore.get(REGION, FUNCTION_NAME, "live")).thenReturn(Optional.of(alias));
+
+ Execution execution = run(optimizedInvocation(reference, "live"));
+
+ assertEquals("SUCCEEDED", execution.getStatus());
+ JsonNode output = objectMapper.readTree(execution.getOutput());
+ assertEquals("V2", output.path("Payload").path("marker").asText());
+ assertEquals("2", output.path("ExecutedVersion").asText());
+ verify(lambdaExecutor).invoke(any(LambdaFunction.class), any(byte[].class),
+ eq(InvocationType.RequestResponse), eq(0), eq("live"));
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"echo-lambda", "echo-lambda:2"})
+ void optimizedInvokeUsesAnExplicitVersion(String reference) throws Exception {
+ stubVersion("2", "V2");
+
+ Execution execution = run(optimizedInvocation(reference, "2"));
+
+ assertEquals("SUCCEEDED", execution.getStatus());
+ assertEquals("V2", objectMapper.readTree(execution.getOutput()).path("Payload").path("marker").asText());
+ verify(lambdaExecutor).invoke(any(LambdaFunction.class), any(byte[].class),
+ eq(InvocationType.RequestResponse), eq(0), eq("2"));
+ }
+
+ @ParameterizedTest
+ @CsvSource({"echo-lambda:1, 2", "echo-lambda, invalid.alias"})
+ void optimizedInvokeRejectsAnInconsistentOrInvalidQualifier(String reference, String qualifier) {
+ Execution execution = run(optimizedInvocation(reference, qualifier));
+
+ assertEquals("FAILED", execution.getStatus());
+ assertEquals("Lambda.InvalidParameterValueException", execution.getError());
+ verifyNoInteractions(lambdaExecutor);
+ }
+
+ private static String optimizedInvocation(String reference, String qualifier) {
+ return """
+ {"StartAt":"Call","States":{"Call":{"Type":"Task",
+ "Resource":"arn:aws:states:::lambda:invoke",
+ "Parameters":{"FunctionName":"%s","Qualifier":"%s","Payload":{}},"End":true}}}
+ """.formatted(reference, qualifier);
+ }
+
private void stubVersion(String version, String marker) throws Exception {
LambdaFunction function = new LambdaFunction();
function.setFunctionName(FUNCTION_NAME);
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java
index 59ccfd0dd0..973a2e83e8 100644
--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java
@@ -145,6 +145,29 @@ class StepFunctionsLambdaTaskAuthorizationIntegrationTest {
.body("error", equalTo("Lambda.AccessDeniedException"));
}
+ @Test
+ void anExplicitAliasParameterUsesTheAliasGrantAndInvocationQualifier() {
+ String roleArn = createRole("sfn-exec-" + suffix(), INVOKE_ANYTHING);
+ String name = "worker-" + suffix();
+ String functionArn = createFunction(FUNCTION_ACCOUNT, name);
+ publishVersionAndAlias(name, "live");
+ addPermission(functionArn, "live", Map.of("Principal", SFN_ACCOUNT));
+
+ run(roleArn, "explicit-alias-" + suffix(), """
+ {"StartAt":"Call","States":{"Call":{"Type":"Task",
+ "Resource":"arn:aws:states:::lambda:invoke",
+ "Parameters":{"FunctionName":"%s","Qualifier.$":"$.alias","Payload":{}},
+ "End":true}}}""".formatted(functionArn), "{\"alias\":\"live\"}")
+ .body("status", equalTo("SUCCEEDED"))
+ .body("output", containsString("\"ExecutedVersion\":\"1\""));
+
+ verify(executor).invoke(argThat(isFunction(functionArn + ":1")), any(), any(), eq(0), eq("live"));
+ runTask(roleArn, functionArn)
+ .body("status", equalTo("FAILED"))
+ .body("error", equalTo("Lambda.AccessDeniedException"));
+ verify(executor, never()).invoke(argThat(isFunction(functionArn)), any(), any());
+ }
+
@Test
void inItsOwnAccountTheRolesPermissionIsEnough() {
String roleArn = createRole("sfn-exec-" + suffix(), INVOKE_ANYTHING);