Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): enforce function policies on cross-account calls (#5476)
Priamo Germosen6d7d85f0f815
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 9e9221cd78..d96f10e2d3 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -989,6 +989,7 @@ When `FLOCI_SERVICES_IAM_ENFORCEMENT_ENABLED` is active, Floci also queries regi- An explicit **Deny** in a resource policy overrides any allows.- In cross-account scenarios or resource-controlled access, an explicit **Allow** in a resource policy grants access to the principal.- For detailed S3 bucket policy behavior and configuration, see [S3 Bucket Policy Enforcement](s3.md#bucket-policy-enforcement).+- Lambda function policies, the statements `AddPermission` adds, take part the same way. An invoke of another account's function by ARN runs it in that account, so its function policy has to allow the caller as well; see [Function policies under IAM enforcement](lambda.md#function-policies-under-iam-enforcement).### Service control policies (SCPs)@@ -1201,9 +1202,8 @@ being bounded by SCPs (below): both forms of root enforcement now agree. A negatabsent key cannot equal what the policy names, so the condition holds, and a `Deny` writtenthat way applies when the key is missing.-**Not yet supported**: `NotPrincipal`, resource-based policies (S3 bucket policy, Lambda resource-policy), and `dynamodb:LeadingKeys` for `Scan`, `TransactWriteItems` / `TransactGetItems` and the-PartiQL operations.+**Not yet supported**: `dynamodb:LeadingKeys` for `Scan`, `TransactWriteItems` / `TransactGetItems`+and the PartiQL operations.### Assumed rolesdiff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex 43c088e4d5..893c55fe7d 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -73,6 +73,29 @@ The event invoke configuration is stored and returned as AWS does, and `AWS::Lamprovisions it from a stack. Asynchronous invocations apply its retry, event age, destination settings,and dead-letter queue configurations (`DeadLetterConfig`).+### Function policies under IAM enforcement++With [IAM enforcement](iam.md#resource-based-policies) on, the statements `AddPermission` adds take+part in authorizing calls to the function:++- An invoke of a function named by a full or partial ARN runs the function in the account in the+ ARN. An invoke of another account's function needs its function policy to allow the caller as+ well as the caller's own identity policy.+- `GetFunction`, `GetFunctionConfiguration` and `ListDurableExecutionsByFunction`, given a full ARN+ with a version or alias, read the function in the account in the ARN, and need its function+ policy to allow the caller in the same way.+- Other operations act on the caller's own function of the name the ARN gives, whatever account+ the ARN names, and are authorized against that function. Floci does not serve them on another+ account's function, which AWS allows through a function policy.+- Within one account, a statement naming the caller grants on its own.+- An invoke is authorized against the version or alias it names, in the function name or in+ `Qualifier`. A grant added with `Qualifier` covers that version or alias only, and a grant on the+ function does not cover a qualified invoke. Other operations are authorized against the+ unqualified function.+- A statement conditioned on `InvokedViaFunctionUrl` does not admit a direct `Invoke`.+- `aws:PrincipalOrgID` is not part of the request context, so a grant added with `PrincipalOrgID`+ admits no caller.+### Reserved ConcurrencyUnqualified `GetFunction` reads include `Concurrency.ReservedConcurrentExecutions` when a reservationdiff --git a/docs/services/secrets-manager.md b/docs/services/secrets-manager.mdindex 42bc96724d..9382fd6d82 100644--- a/docs/services/secrets-manager.md+++ b/docs/services/secrets-manager.md@@ -140,10 +140,14 @@ aws secretsmanager validate-resource-policy \- **`RotateSecret` also needs `lambda:InvokeFunction` under IAM enforcement.** As on AWS, the callermust be allowed to invoke the rotation function as well as to call `RotateSecret`. A caller thatis not gets `AccessDeniedException` with HTTP 400, as Secrets Manager reports it, and the secret is- left as it was. Rotations started by the background sweep have no caller and are not checked.+ left as it was. A function in another account is checked as any cross-account call is: its+ function policy must allow the caller too. Rotations started by the background sweep have no+ caller and are not checked.- **A rotation function that does not exist** is reported as AWS reports it: `AccessDeniedException`- (HTTP 400), "Secrets Manager cannot invoke the specified Lambda function". The secret's rotation- settings are left as they were, including any rotation function configured before.+ (HTTP 400), "Secrets Manager cannot invoke the specified Lambda function". The function is looked+ up where the rotation runs it, in the account its ARN names and as the version or alias the ARN+ names, so a missing alias is reported the same way. The secret's rotation settings are left as+ they were, including any rotation function configured before.- **A rotation function reference Lambda refuses**, one it cannot parse or a full ARN in anotherRegion, gets `InvalidParameterException` (HTTP 400), the error `RotateSecret` declares for aninvalid parameter, with Lambda's reason in the message. The secret is left as it was. AWS does notdiff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.javaindex 1322b80a17..7e7e579af3 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.iam;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsQueryServiceResolver;import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.ServicePrincipals;@@ -78,7 +79,7 @@ public class ResourceArnBuilder {String path = ctx.getUriInfo().getPath();return switch (credentialScope) {case "s3" -> List.of(buildS3Arn(path, region));- case "lambda" -> List.of(buildLambdaArn(path, region, accountId));+ case "lambda" -> List.of(buildLambdaArn(path, ctx, region, accountId));case "sqs" -> List.of(buildSqsArn(ctx, region, accountId));case "sns" -> List.of(buildSnsArn(ctx, region, accountId));case "dynamodb" -> buildDynamoDbArns(ctx, region, accountId);@@ -541,7 +542,19 @@ public class ResourceArnBuilder {}// ── Lambda ──────────────────────────────────────────────────────────────────- private String buildLambdaArn(String path, String region, String accountId) {++ /**+ * The function a Lambda request acts on, as an IAM policy names it. An invoke runs the function+ * in the account and Region its full or partial ARN names, so it is evaluated against that+ * function, and against the version or alias it names in the function name or in+ * {@code Qualifier}, since Lambda authorizes a qualified call against the qualified ARN (Lambda+ * Developer Guide, "Referencing functions in the Resource section of policies"). The reads+ * {@link #readsInTheAccountItNames} names act in the account a qualified ARN names too. Every+ * other route acts on the caller's own function of that name, whatever account an ARN names.+ * Those are evaluated unqualified, because not every one of them acts on the qualifier it is+ * given.+ */+ private String buildLambdaArn(String path, ContainerRequestContext ctx, String region, String accountId) {String executionArn = durableExecutionArn(path);if (executionArn == null) {executionArn = durableCallbackExecutionArn(path);@@ -552,10 +565,49 @@ public class ResourceArnBuilder {// path: /2015-03-31/functions/name or similarString name = extractSegmentAfter(path, "functions");if (name == null) return "*";- // strip qualifier if present- int colon = name.indexOf(':');- if (colon > 0) name = name.substring(0, colon);- return AwsArnUtils.Arn.of("lambda", region, accountId, "function:" + name).toString();+ boolean invoke = path.endsWith("/functions/" + name + "/invocations");+ try {+ if (!invoke) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(name);+ boolean namedAccount = readsInTheAccountItNames(path, name, ref, ctx);+ return AwsArnUtils.Arn.of("lambda",+ namedAccount ? ref.region() : region,+ namedAccount ? ref.account() : accountId,+ "function:" + ref.name()).toString();+ }+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier(+ name, ctx.getUriInfo().getQueryParameters().getFirst("Qualifier"));+ String resource = ref.qualifier() != null+ ? "function:" + ref.name() + ":" + ref.qualifier()+ : "function:" + ref.name();+ return AwsArnUtils.Arn.of("lambda",+ ref.region() != null ? ref.region() : region,+ ref.account() != null ? ref.account() : accountId,+ resource).toString();+ } catch (AwsException e) {+ // A reference Lambda refuses, which its handler answers with a 400 before acting on anything.+ return AwsArnUtils.Arn.of("lambda", region, accountId, "function:" + name).toString();+ }+ }++ /**+ * {@code GetFunction}, {@code GetFunctionConfiguration} and {@code ListDurableExecutionsByFunction}+ * read a function named by a qualified full ARN in the account the ARN names, where the version or+ * alias is resolved ({@code LambdaService.getFunction(region, name, qualifier)}). Unqualified, or+ * by partial ARN, they read the caller's own function of that name, as every other route acts.+ */+ private static boolean readsInTheAccountItNames(String path, String name,+ LambdaArnUtils.ResolvedFunctionRef ref,+ ContainerRequestContext ctx) {+ if (!"GET".equals(ctx.getMethod()) || !name.startsWith("arn:")) {+ return false;+ }+ String route = path.substring(path.indexOf("/functions/" + name) + "/functions/".length() + name.length());+ if (!route.isEmpty() && !route.equals("/configuration") && !route.equals("/durable-executions")) {+ return false;+ }+ String qualifier = ctx.getUriInfo().getQueryParameters().getFirst("Qualifier");+ return ref.qualifier() != null || (qualifier != null && !qualifier.isBlank());}/** Durable execution actions are authorized against the execution ARN, which carries the version. */diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProvider.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProvider.javanew file mode 100644index 0000000000..911a489464--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProvider.java@@ -0,0 +1,81 @@+package io.github.hectorvent.floci.services.lambda;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.services.iam.ResourcePolicyProvider;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.regex.Matcher;+import java.util.regex.Pattern;++/**+ * Supplies Lambda function policies to the IAM policy evaluation pipeline, together with the account+ * that owns the function.+ *+ * <p>The owner is the account in the function ARN, and it is returned even when the function has no+ * policy or does not exist: a call to another account's function is then judged as cross-account,+ * which needs the function policy to allow the caller as well as the caller's own policy (Lambda+ * Developer Guide, function URLs: "If the principal making the request is in a different account,+ * then the principal must have both an identity-based policy ... and permissions granted to them in+ * a resource-based policy").+ *+ * <p>All of a function's statements are returned, its own and those of its versions and aliases. Each+ * statement's {@code Resource} names the function, version or alias it was added to, so matching it+ * against the ARN the call names is what scopes it: a grant on an alias covers calls to that alias+ * only, and one on the function does not cover a qualified call (Lambda Developer Guide, "Referencing+ * functions in the Resource section of policies").+ *+ * <p>Keyed on the ARN rather than the request's credential scope, because a function is also the+ * second resource of calls signed for another service: {@code RotateSecret} checks+ * {@code lambda:InvokeFunction} on its rotation function under the {@code secretsmanager} scope.+ */+@ApplicationScoped+public class LambdaResourcePolicyProvider implements ResourcePolicyProvider {++ private static final Pattern ACCOUNT_ID = Pattern.compile("\\d{12}");+ /** A function, version or alias, or a durable execution under one: the name is group 1. */+ private static final Pattern FUNCTION_RESOURCE = Pattern.compile("function:([^:/]+)(?:[:/].*)?");++ private final LambdaService lambdaService;+ private final ObjectMapper objectMapper;++ @Inject+ public LambdaResourcePolicyProvider(LambdaService lambdaService, ObjectMapper objectMapper) {+ this.lambdaService = lambdaService;+ this.objectMapper = objectMapper;+ }++ @Override+ public List<ResourcePolicy> getResourcePolicies(String credentialScope, String resourceArn) {+ if (!AwsArnUtils.isArnFor(resourceArn, "lambda")) {+ return List.of();+ }+ AwsArnUtils.Arn arn = AwsArnUtils.parse(resourceArn);+ Matcher function = FUNCTION_RESOURCE.matcher(arn.resource());+ if (!function.matches() || !ACCOUNT_ID.matcher(arn.accountId()).matches()) {+ return List.of();+ }+ List<Map<String, Object>> statements =+ lambdaService.policyStatements(arn.accountId(), arn.region(), function.group(1));+ return List.of(new ResourcePolicy(policyDocument(statements), arn.accountId()));+ }++ private String policyDocument(List<Map<String, Object>> statements) {+ if (statements.isEmpty()) {+ return null;+ }+ Map<String, Object> policy = new LinkedHashMap<>();+ policy.put("Version", "2012-10-17");+ policy.put("Statement", statements);+ try {+ return objectMapper.writeValueAsString(policy);+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Could not serialize the function policy", e);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex 9f7f45123e..7394fb327f 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java@@ -1232,9 +1232,10 @@ public class LambdaService implements ResourceProvider {String name = ref.name();String qualifier = ref.qualifier();LambdaFunction fn;- if (functionName.startsWith("arn:")) {- AwsArnUtils.Arn arn = AwsArnUtils.parse(functionName);- fn = targetResolver.resolveInvokeTargetForAccount(arn.accountId(), region, name, qualifier);+ // A full or partial ARN names its account, which is where the function runs and what IAM+ // enforcement authorized the call against.+ if (ref.account() != null) {+ fn = targetResolver.resolveInvokeTargetForAccount(ref.account(), region, name, qualifier);} else {fn = targetResolver.resolveInvokeTarget(region, name, qualifier);}@@ -3731,6 +3732,40 @@ public class LambdaService implements ResourceProvider {}}+ /**+ * Every statement in the resource-based policies of a function in {@code accountId}: the+ * function's own and those of each of its versions and aliases, which each statement's+ * {@code Resource} tells apart. Read under the lock the policy mutations hold, so a statement+ * being added or removed is seen whole or not at all. Empty when the function does not exist or+ * has no policy.+ */+ public List<Map<String, Object>> policyStatements(String accountId, String region, String functionName) {+ Optional<LambdaFunction> observed = functionStore.getForAccount(accountId, region, functionName);+ if (observed.isEmpty()) {+ return List.of();+ }+ synchronized (lockForPolicyMutation(observed.get().getFunctionArn())) {+ return functionStore.getForAccount(accountId, region, functionName)+ .map(fn -> fn.getPolicies().stream()+ .<Map<String, Object>>map(LinkedHashMap::new)+ .toList())+ .orElse(List.of());+ }+ }++ /**+ * Reads the function, version or alias a full ARN names, in the ARN's own account and Region,+ * where an invoke of that ARN runs it. {@link #getFunction(String, String)} reads a name in the+ * caller's account, which for another account's ARN is a different function or none.+ */+ public LambdaFunction getFunctionByArn(String functionArn) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(functionArn);+ if (ref.region() == null || ref.account() == null) {+ throw new AwsException("InvalidParameterValueException", "Not a function ARN: " + functionArn, 400);+ }+ return targetResolver.resolveReadTargetForAccount(ref.account(), ref.region(), ref.name(), ref.qualifier());+ }+/*** Puts a previously captured policy statement back. Used to compensate when a replacement fails* after the original was removed: it takes the stored statement shape rather than andiff --git a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.javaindex e868a149f1..fd561528ce 100644--- a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java+++ b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java@@ -1149,10 +1149,11 @@ public class SecretsManagerService implements ResourceProvider {// A function that cannot be found is reported the way AWS reports it, AccessDeniedException with// HTTP 400; any other reference Lambda refuses is an invalid RotationLambdaARN. Either way the- // secret is left as it was.+ // secret is left as it was. The function is looked up where the rotation will invoke it: in the+ // ARN's account, and as the version or alias the ARN names.if (!serviceManaged && lambdaService != null) {try {- lambdaService.getFunction(region, functionArn);+ lambdaService.getFunctionByArn(functionArn);} catch (AwsException e) {if (e.getHttpStatus() == 404) {throw new AwsException("AccessDeniedException",diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.javaindex 8ad8f0be99..4ea4568da0 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java@@ -903,6 +903,94 @@ class ResourceArnBuilderTest {assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function", arn);}+ @Test+ void lambdaFunctionArnKeepsTheAccountItNames() {+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function/invocations");+ assertEquals("arn:aws:lambda:us-east-1:111122223333:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/111122223333:function:my-function/invocations");+ assertEquals("arn:aws:lambda:us-east-1:111122223333:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }++ @Test+ void lambdaInvokeKeepsTheQualifierItRuns() {+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function:live/invocations");+ assertEquals("arn:aws:lambda:us-east-1:111122223333:function:my-function:live",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/my-function/invocations");+ queryParams.putSingle("Qualifier", "1");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function:1",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }++ @Test+ void lambdaRoutesOtherThanInvokeAreCheckedAgainstTheCallersUnqualifiedFunction() {+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function:1/code");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/111122223333:function:my-function/policy");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/my-function");+ queryParams.putSingle("Qualifier", "1");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }++ @Test+ void lambdaQualifiedReadsByArnAreCheckedInTheAccountTheyRead() {+ when(ctx.getMethod()).thenReturn("GET");+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function:1");+ assertEquals("arn:aws:lambda:us-east-1:111122223333:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function/configuration");+ queryParams.putSingle("Qualifier", "live");+ assertEquals("arn:aws:lambda:us-east-1:111122223333:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }++ @Test+ void lambdaReadsThatDoNotFollowTheArnAreCheckedOnTheCallersFunction() {+ when(ctx.getMethod()).thenReturn("GET");+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/111122223333:function:my-function:1");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function:1/policy");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));++ when(ctx.getMethod()).thenReturn("DELETE");+ when(uriInfo.getPath()).thenReturn(+ "/2015-03-31/functions/arn:aws:lambda:us-east-1:111122223333:function:my-function:1");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:my-function",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }++ @Test+ void lambdaReferenceLambdaRefusesIsNamedAsGiven() {+ when(uriInfo.getPath()).thenReturn("/2015-03-31/functions/not:a:function:ref/invocations");+ assertEquals("arn:aws:lambda:us-east-1:000000000000:function:not:a:function:ref",+ builder.build("lambda", ctx, "us-east-1", "000000000000"));+ }+@Testvoid lambdaDurableExecutionRoutesNameTheExecution() {when(uriInfo.getPath()).thenReturn("/2025-12-01/durable-executions/arn:aws:lambda:us-east-1:000000000000:"diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCrossAccountInvokeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCrossAccountInvokeIntegrationTest.javanew file mode 100644index 0000000000..1d6fd12f99--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaCrossAccountInvokeIntegrationTest.java@@ -0,0 +1,441 @@+package io.github.hectorvent.floci.services.lambda;++import io.github.hectorvent.floci.services.lambda.model.InvokeResult;+import io.github.hectorvent.floci.services.lambda.model.LambdaFunction;+import io.github.hectorvent.floci.testing.IamEnforcementProfile;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.InjectMock;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentMatcher;++import java.nio.charset.StandardCharsets;+import java.time.Duration;+import java.util.ArrayDeque;+import java.util.Deque;+import java.util.LinkedHashMap;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.awaitility.Awaitility.await;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.startsWith;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyInt;+import static org.mockito.ArgumentMatchers.argThat;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.timeout;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * Under IAM enforcement, a call to a function in another account needs the function policy to allow+ * the caller as well as the caller's own policy (Lambda Developer Guide, function URLs: "If the+ * principal making the request is in a different account, then the principal must have both an+ * identity-based policy ... and permissions granted to them in a resource-based policy"). Lambda+ * authorizes a call against the function, version or alias ARN the call names, so a function addressed+ * by ARN is evaluated as that ARN, in its own account and with its qualifier.+ */+@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class LambdaCrossAccountInvokeIntegrationTest {++ private static final String REGION = "us-east-1";+ private static final String OWNER = "444455556666";+ private static final String CALLER = "777788889999";+ private static final String SM_CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final String INVOKE_ANYTHING = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"lambda:InvokeFunction","Resource":"*"}]}""";+ private static final String ROTATE_AND_INVOKE = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"secretsmanager:*","Resource":"*"},+ {"Effect":"Allow","Action":"lambda:InvokeFunction","Resource":"*"}]}""";++ @InjectMock+ LambdaExecutorService executor;++ /** How to delete each thing the test created, pushed as it is created and run newest first. */+ private final Deque<Runnable> cleanup = new ArrayDeque<>();++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @BeforeEach+ void stubExecutor() {+ when(executor.invoke(any(), any(), any(), anyInt(), any(), any()))+ .thenReturn(new InvokeResult(200, null, "{}".getBytes(StandardCharsets.UTF_8), null, "req"));+ }++ @AfterEach+ void deleteWhatTheTestCreated() {+ while (!cleanup.isEmpty()) {+ cleanup.pop().run();+ }+ }++ @Test+ void anotherAccountsFunctionIsRefusedWhenItsPolicyGrantsNothing() {+ String functionArn = createFunction(OWNER, "victim-" + suffix());+ String caller = createUser(CALLER, "invoker-" + suffix(), INVOKE_ANYTHING);++ invoke(caller, functionArn)+ .statusCode(403)+ .body("__type", equalTo("AccessDeniedException"));++ verify(executor, never()).invoke(argThat(isFunction(functionArn)), any(), any(), anyInt(), any(), any());+ }++ @Test+ void aGrantToTheCallersAccountLetsItInvoke() {+ String functionArn = createFunction(OWNER, "shared-" + suffix());+ addPermission(OWNER, functionArn, null, Map.of("Principal", CALLER));+ String caller = createUser(CALLER, "invoker-" + suffix(), INVOKE_ANYTHING);++ invoke(caller, functionArn).statusCode(200);++ verify(executor).invoke(argThat(isFunction(functionArn)), any(), any(), anyInt(), any(), any());+ }++ @Test+ void aGrantDoesNotStandInForTheCallersOwnPolicy() {+ String functionArn = createFunction(OWNER, "shared-" + suffix());+ addPermission(OWNER, functionArn, null, Map.of("Principal", CALLER));+ String caller = createUser(CALLER, "no-lambda-" + suffix(), """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:ListAllMyBuckets","Resource":"*"}]}""");++ invoke(caller, functionArn).statusCode(403);+ }++ @Test+ void aPartialArnReachesTheAccountItNames() {+ String name = "partial-" + suffix();+ String functionArn = createFunction(OWNER, name);+ String caller = createUser(CALLER, "invoker-" + suffix(), INVOKE_ANYTHING);++ invoke(caller, OWNER + ":function:" + name).statusCode(403);++ addPermission(OWNER, functionArn, null, Map.of("Principal", CALLER));+ invoke(caller, OWNER + ":function:" + name).statusCode(200);++ verify(executor).invoke(argThat(isFunction(functionArn)), any(), any(), anyInt(), any(), any());+ }++ @Test+ void aGrantNamingARoleCoversThatRolesSessionsOnly() {+ String functionArn = createFunction(OWNER, "role-scoped-" + suffix());+ String grantedRole = "deploy.bot-" + suffix();+ String otherRole = "other-" + suffix();+ createRole(CALLER, grantedRole, INVOKE_ANYTHING);+ createRole(CALLER, otherRole, INVOKE_ANYTHING);+ addPermission(OWNER, functionArn, null,+ Map.of("Principal", "arn:aws:iam::" + CALLER + ":role/" + grantedRole));++ invoke(assumeRole(CALLER, grantedRole), functionArn).statusCode(200);+ invoke(assumeRole(CALLER, otherRole), functionArn).statusCode(403);+ }++ @Test+ void anAliasGrantCoversThatAliasOnly() {+ String name = "aliased-" + suffix();+ String functionArn = createFunction(OWNER, name);+ publishVersionAndAlias(OWNER, name, "live");+ addPermission(OWNER, functionArn, "live", Map.of("Principal", CALLER));+ String caller = createUser(CALLER, "invoker-" + suffix(), INVOKE_ANYTHING);++ invoke(caller, functionArn + ":live").statusCode(200);+ invoke(caller, functionArn, "live").statusCode(200);+ invoke(caller, functionArn).statusCode(403);+ invoke(caller, functionArn + ":1").statusCode(403);+ }++ @Test+ void aPublicFunctionUrlGrantDoesNotAdmitADirectInvoke() {+ String functionArn = createFunction(OWNER, "url-only-" + suffix());+ addPermission(OWNER, functionArn, null, Map.of("Principal", "*", "InvokedViaFunctionUrl", true));+ String caller = createUser(CALLER, "invoker-" + suffix(), INVOKE_ANYTHING);++ invoke(caller, functionArn).statusCode(403);+ }++ @Test+ void aDenyOnTheFunctionArnAppliesToAnInvokeByArn() {+ String name = "guarded-" + suffix();+ String functionArn = createFunction(OWNER, name);+ String user = createUser(OWNER, "denied-" + suffix(), """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"lambda:InvokeFunction","Resource":"*"},+ {"Effect":"Deny","Action":"lambda:InvokeFunction","Resource":"%s"}]}""".formatted(functionArn));++ invoke(user, name).statusCode(403);+ invoke(user, functionArn).statusCode(403);+ invoke(user, OWNER + ":function:" + name).statusCode(403);++ verify(executor, never()).invoke(argThat(isFunction(functionArn)), any(), any(), anyInt(), any(), any());+ }++ @Test+ void aSameAccountFunctionPolicyGrantsOnItsOwn() {+ String functionArn = createFunction(OWNER, "own-grant-" + suffix());+ String userName = "granted-" + suffix();+ String user = createUser(OWNER, userName, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:ListAllMyBuckets","Resource":"*"}]}""");+ addPermission(OWNER, functionArn, null, Map.of("Principal", "arn:aws:iam::" + OWNER + ":user/" + userName));++ invoke(user, functionArn).statusCode(200);+ }++ /**+ * Operations other than invoke act on the caller's own function of the name an ARN gives, whatever+ * account it names, so they are authorized against that function: a grant from the account the+ * ARN names does not get past a Deny on the function the call actually changes.+ */+ @Test+ void aManagementCallNamingAnotherAccountsArnIsCheckedAgainstTheFunctionItChanges() {+ String name = "managed-" + suffix();+ String foreignArn = createFunction(OWNER, name);+ String ownArn = createFunction(CALLER, name);+ addPermission(OWNER, foreignArn, null, Map.of("Principal", CALLER, "Action", "lambda:DeleteFunction"));+ String user = createUser(CALLER, "deleter-" + suffix(), """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"lambda:*","Resource":"*"},+ {"Effect":"Deny","Action":"lambda:DeleteFunction","Resource":"%s"}]}""".formatted(ownArn));++ lambda(user).delete("/2015-03-31/functions/{name}", foreignArn).then().statusCode(403);++ lambda(CALLER).get("/2015-03-31/functions/{name}", name).then().statusCode(200);+ lambda(OWNER).get("/2015-03-31/functions/{name}", name).then().statusCode(200);+ }++ /**+ * {@code GetFunction} reads a function named by a qualified ARN in the account the ARN names, so+ * that account's function policy has to allow the caller, as for an invoke.+ */+ @Test+ void aQualifiedReadOfAnotherAccountsFunctionNeedsItsGrant() {+ String foreignArn = createFunction(OWNER, "read-" + suffix());+ String user = createUser(CALLER, "reader-" + suffix(), """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"lambda:GetFunction","Resource":"*"}]}""");++ lambda(user).get("/2015-03-31/functions/{name}", foreignArn + ":$LATEST").then().statusCode(403);+ lambda(user).queryParam("Qualifier", "$LATEST").get("/2015-03-31/functions/{name}", foreignArn)+ .then().statusCode(403);++ addPermission(OWNER, foreignArn, null, Map.of("Principal", CALLER, "Action", "lambda:GetFunction"));+ lambda(user).get("/2015-03-31/functions/{name}", foreignArn + ":$LATEST")+ .then().statusCode(200).body("Configuration.FunctionArn", startsWith(foreignArn));+ }++ @Test+ void rotateSecretIsRefusedForAnotherAccountsFunctionThatGrantsNothing() {+ String name = "rotator-" + suffix();+ String foreignArn = createFunction(OWNER, name);+ createFunction(CALLER, name);+ String caller = createUser(CALLER, "rotator-user-" + suffix(), ROTATE_AND_INVOKE);+ String secretName = createSecret(caller, "foreign-" + suffix());++ secretsManager(caller, "RotateSecret",+ "{\"SecretId\":\"" + secretName + "\",\"RotationLambdaARN\":\"" + foreignArn + "\"}")+ .statusCode(400)+ .body("__type", equalTo("AccessDeniedException"));++ verify(executor, never()).invoke(argThat(isFunction(foreignArn)), any(), any(), anyInt(), any(), any());+ }++ @Test+ void rotateSecretRunsAnotherAccountsFunctionThatGrantsTheCaller() {+ String foreignArn = createFunction(OWNER, "rotator-" + suffix());+ addPermission(OWNER, foreignArn, null, Map.of("Principal", CALLER));+ String caller = createUser(CALLER, "rotator-user-" + suffix(), ROTATE_AND_INVOKE);+ String secretName = createSecret(caller, "granted-" + suffix());++ secretsManager(caller, "RotateSecret",+ "{\"SecretId\":\"" + secretName + "\",\"RotationLambdaARN\":\"" + foreignArn + "\"}")+ .statusCode(200);++ verify(executor, timeout(5000).atLeastOnce())+ .invoke(argThat(isFunction(foreignArn)), any(), any(), anyInt(), any(), any());+ awaitRotationFinished(caller, secretName);+ }++ @Test+ void rotateSecretRefusesAnAliasTheFunctionDoesNotHave() {+ String functionArn = createFunction(OWNER, "rotator-" + suffix());+ String user = createUser(OWNER, "rotator-user-" + suffix(), ROTATE_AND_INVOKE);+ String secretName = createSecret(user, "no-alias-" + suffix());++ secretsManager(user, "RotateSecret",+ "{\"SecretId\":\"" + secretName + "\",\"RotationLambdaARN\":\"" + functionArn + ":nosuchalias\"}")+ .statusCode(400)+ .body("__type", equalTo("AccessDeniedException"));++ verify(executor, never()).invoke(any(), any(), any(), anyInt(), any(), any());+ }++ private static String suffix() {+ return UUID.randomUUID().toString().substring(0, 8);+ }++ private static ArgumentMatcher<LambdaFunction> isFunction(String functionArn) {+ return fn -> fn != null && functionArn.equals(fn.getFunctionArn());+ }++ private String createFunction(String account, String name) {+ lambda(account)+ .body("""+ {"FunctionName":"%s","Runtime":"nodejs20.x","Handler":"index.handler",+ "Role":"arn:aws:iam::%s:role/lambda-role"}""".formatted(name, account))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(201);+ cleanup.push(() -> lambda(account).delete("/2015-03-31/functions/{name}", name).then().statusCode(204));+ return "arn:aws:lambda:" + REGION + ":" + account + ":function:" + name;+ }++ private static void publishVersionAndAlias(String account, String name, String alias) {+ lambda(account).body("{}").post("/2015-03-31/functions/{name}/versions", name).then().statusCode(201);+ lambda(account)+ .body("{\"Name\":\"" + alias + "\",\"FunctionVersion\":\"1\"}")+ .post("/2015-03-31/functions/{name}/aliases", name)+ .then()+ .statusCode(201);+ }++ /** Adds a statement granting {@code lambda:InvokeFunction} unless {@code grant} names another action. */+ private static void addPermission(String account, String functionArn, String qualifier, Map<String, Object> grant) {+ Map<String, Object> request = new LinkedHashMap<>();+ request.put("StatementId", "s-" + suffix());+ request.put("Action", "lambda:InvokeFunction");+ request.putAll(grant);+ RequestSpecification spec = lambda(account).body(request);+ if (qualifier != null) {+ spec.queryParam("Qualifier", qualifier);+ }+ spec.post("/2015-03-31/functions/{name}/policy", functionArn).then().statusCode(201);+ }++ private static ValidatableResponse invoke(String accessKeyId, String functionName) {+ return invoke(accessKeyId, functionName, null);+ }++ private static ValidatableResponse invoke(String accessKeyId, String functionName, String qualifier) {+ RequestSpecification spec = given()+ .header("Authorization", authorization(accessKeyId, "lambda"))+ .contentType("application/json")+ .body("{}");+ if (qualifier != null) {+ spec.queryParam("Qualifier", qualifier);+ }+ return spec.when().post("/2015-03-31/functions/{name}/invocations", functionName).then();+ }++ private static RequestSpecification lambda(String accessKeyId) {+ return given()+ .header("Authorization", authorization(accessKeyId, "lambda"))+ .contentType("application/json");+ }++ private String createSecret(String accessKeyId, String secretName) {+ secretsManager(accessKeyId, "CreateSecret",+ "{\"Name\":\"" + secretName + "\",\"SecretString\":\"v1\"}").statusCode(200);+ cleanup.push(() -> secretsManager(accessKeyId, "DeleteSecret",+ "{\"SecretId\":\"" + secretName + "\",\"ForceDeleteWithoutRecovery\":true}").statusCode(200));+ return secretName;+ }++ private static ValidatableResponse secretsManager(String accessKeyId, String operation, String body) {+ return given()+ .header("Authorization", authorization(accessKeyId, "secretsmanager"))+ .header("X-Amz-Target", "secretsmanager." + operation)+ .contentType(SM_CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }++ /**+ * Lets the rotation finish before cleanup deletes the secret, which it would otherwise go on+ * trying to update.+ */+ private static void awaitRotationFinished(String accessKeyId, String secretName) {+ await().atMost(Duration.ofSeconds(5)).until(() -> secretsManager(accessKeyId, "DescribeSecret",+ "{\"SecretId\":\"" + secretName + "\"}").statusCode(200).extract().path("LastRotatedDate") != null);+ }++ private String createUser(String account, String userName, String policyDocument) {+ iam(account, "CreateUser", Map.of("UserName", userName)).statusCode(200);+ cleanup.push(() -> iam(account, "DeleteUser", Map.of("UserName", userName)).statusCode(200));+ iam(account, "PutUserPolicy", Map.of(+ "UserName", userName,+ "PolicyName", "inline",+ "PolicyDocument", policyDocument)).statusCode(200);+ cleanup.push(() -> iam(account, "DeleteUserPolicy",+ Map.of("UserName", userName, "PolicyName", "inline")).statusCode(200));+ String accessKeyId = iam(account, "CreateAccessKey", Map.of("UserName", userName))+ .statusCode(200)+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");+ cleanup.push(() -> iam(account, "DeleteAccessKey",+ Map.of("UserName", userName, "AccessKeyId", accessKeyId)).statusCode(200));+ return accessKeyId;+ }++ private void createRole(String account, String roleName, String policyDocument) {+ iam(account, "CreateRole", Map.of(+ "RoleName", roleName,+ "AssumeRolePolicyDocument", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::%s:root"},"Action":"sts:AssumeRole"}]}"""+ .formatted(account))).statusCode(200);+ cleanup.push(() -> iam(account, "DeleteRole", Map.of("RoleName", roleName)).statusCode(200));+ iam(account, "PutRolePolicy", Map.of(+ "RoleName", roleName,+ "PolicyName", "inline",+ "PolicyDocument", policyDocument)).statusCode(200);+ cleanup.push(() -> iam(account, "DeleteRolePolicy",+ Map.of("RoleName", roleName, "PolicyName", "inline")).statusCode(200));+ }++ private static String assumeRole(String account, String roleName) {+ return given()+ .header("Authorization", authorization(account, "sts"))+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "AssumeRole")+ .formParam("Version", "2011-06-15")+ .formParam("RoleArn", "arn:aws:iam::" + account + ":role/" + roleName)+ .formParam("RoleSessionName", "s1b")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId");+ }++ private static ValidatableResponse iam(String account, String action, Map<String, String> params) {+ RequestSpecification spec = given()+ .header("Authorization", authorization(account, "iam"))+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("Version", "2010-05-08");+ params.forEach(spec::formParam);+ return spec.when().post("/").then();+ }++ private static String authorization(String accessKeyId, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/20261011/" + REGION + "/" + service+ + "/aws4_request, SignedHeaders=host, Signature=abc";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProviderTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProviderTest.javanew file mode 100644index 0000000000..dc34d67c2a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaResourcePolicyProviderTest.java@@ -0,0 +1,78 @@+package io.github.hectorvent.floci.services.lambda;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.iam.ResourcePolicyProvider.ResourcePolicy;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class LambdaResourcePolicyProviderTest {++ private static final String OWNER = "111122223333";+ private static final String FUNCTION_ARN = "arn:aws:lambda:us-east-1:" + OWNER + ":function:my-function";++ private final ObjectMapper objectMapper = new ObjectMapper();+ private LambdaService lambdaService;+ private LambdaResourcePolicyProvider provider;++ @BeforeEach+ void setUp() {+ lambdaService = mock(LambdaService.class);+ when(lambdaService.policyStatements(OWNER, "us-east-1", "my-function")).thenReturn(List.of());+ provider = new LambdaResourcePolicyProvider(lambdaService, objectMapper);+ }++ @Test+ void theOwnerComesFromTheArnEvenWithoutAPolicy() {+ List<ResourcePolicy> policies = provider.getResourcePolicies("lambda", FUNCTION_ARN);++ assertEquals(1, policies.size());+ assertNull(policies.getFirst().policyDocument());+ assertEquals(OWNER, policies.getFirst().ownerAccountId());+ }++ @Test+ void everyStatementOnTheFunctionComesBackForAQualifiedArn() throws Exception {+ Map<String, Object> functionGrant = Map.of("Sid", "fn", "Effect", "Allow",+ "Principal", Map.of("AWS", "arn:aws:iam::444455556666:root"),+ "Action", "lambda:InvokeFunction", "Resource", FUNCTION_ARN);+ Map<String, Object> aliasGrant = Map.of("Sid", "alias", "Effect", "Allow",+ "Principal", Map.of("AWS", "arn:aws:iam::444455556666:root"),+ "Action", "lambda:InvokeFunction", "Resource", FUNCTION_ARN + ":live");+ when(lambdaService.policyStatements(OWNER, "us-east-1", "my-function"))+ .thenReturn(List.of(functionGrant, aliasGrant));++ List<ResourcePolicy> policies = provider.getResourcePolicies("lambda", FUNCTION_ARN + ":live");++ JsonNode statements = objectMapper.readTree(policies.getFirst().policyDocument()).get("Statement");+ assertEquals(2, statements.size());+ assertEquals(FUNCTION_ARN, statements.get(0).get("Resource").asText());+ assertEquals(FUNCTION_ARN + ":live", statements.get(1).get("Resource").asText());+ assertEquals(OWNER, policies.getFirst().ownerAccountId());+ }++ @Test+ void aFunctionCheckedUnderAnotherServicesScopeIsStillSupplied() {+ List<ResourcePolicy> policies = provider.getResourcePolicies("secretsmanager", FUNCTION_ARN);++ assertEquals(OWNER, policies.getFirst().ownerAccountId());+ }++ @Test+ void resourcesThatAreNotFunctionsAreLeftToOtherProviders() {+ assertTrue(provider.getResourcePolicies("lambda", "*").isEmpty());+ assertTrue(provider.getResourcePolicies("lambda", "arn:aws:lambda:us-east-1:" + OWNER + ":layer:my-layer:1").isEmpty());+ assertTrue(provider.getResourcePolicies("lambda",+ "arn:aws:lambda:us-east-1:" + OWNER + ":event-source-mapping:fa123456-14a1-4fd2-9fec-83de64ad683d").isEmpty());+ assertTrue(provider.getResourcePolicies("s3", "arn:aws:s3:::bucket/key").isEmpty());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationIntegrationTest.javaindex 25ec4899b2..394c36e076 100644--- a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationIntegrationTest.java@@ -60,7 +60,7 @@ class SecretsManagerRotationInvokeAuthorizationIntegrationTest {@BeforeEachvoid stubLambda() {- Mockito.when(lambdaService.getFunction(anyString(), anyString())).thenReturn(new LambdaFunction());+ Mockito.when(lambdaService.getFunctionByArn(anyString())).thenReturn(new LambdaFunction());InvokeResult ok = new InvokeResult();ok.setStatusCode(200);Mockito.when(lambdaService.invoke(any(), any(), any(), any())).thenReturn(ok);diff --git a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationTest.java b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationTest.javaindex e736290b98..358da8df44 100644--- a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerRotationInvokeAuthorizationTest.java@@ -50,7 +50,7 @@ class SecretsManagerRotationInvokeAuthorizationTest {void setUp() {store = new InMemoryStorage<>();lambda = mock(LambdaService.class);- when(lambda.getFunction(anyString(), anyString())).thenReturn(new LambdaFunction());+ when(lambda.getFunctionByArn(anyString())).thenReturn(new LambdaFunction());when(lambda.invoke(anyString(), anyString(), any(byte[].class), any())).thenReturn(new InvokeResult());service = new SecretsManagerService(store, 30, new RegionResolver(REGION, ACCOUNT), lambda, new ObjectMapper());service.createSecret("my-secret", "v1", null, null, null, null, REGION);@@ -116,7 +116,7 @@ class SecretsManagerRotationInvokeAuthorizationTest {@Testvoid lambdaRefusingTheReferenceAtTheLookupIsAnInvalidParameter() {- when(lambda.getFunction(anyString(), anyString()))+ when(lambda.getFunctionByArn(anyString())).thenThrow(new AwsException("ValidationException", "refused by Lambda", 400));AwsException e = assertThrows(AwsException.class, () ->@@ -149,7 +149,7 @@ class SecretsManagerRotationInvokeAuthorizationTest {@Testvoid refusalComesBeforeTheExistenceCheck() {- when(lambda.getFunction(anyString(), anyString()))+ when(lambda.getFunctionByArn(anyString())).thenThrow(new AwsException("ResourceNotFoundException", "Function not found", 404));Consumer<String> refuse = functionArn -> {throw new AwsException("AccessDeniedException", "refused by the caller check", 400);@@ -163,7 +163,7 @@ class SecretsManagerRotationInvokeAuthorizationTest {@Testvoid missingFunctionIsReportedAsSecretsManagerReportsIt() {- when(lambda.getFunction(anyString(), anyString()))+ when(lambda.getFunctionByArn(anyString())).thenThrow(new AwsException("ResourceNotFoundException", "Function not found", 404));AwsException e = assertThrows(AwsException.class, () ->@@ -181,7 +181,7 @@ class SecretsManagerRotationInvokeAuthorizationTest {Secret secret = service.describeSecret("my-secret", REGION);secret.setRotationLambdaArn(FUNCTION_ARN);store.put(REGION + "::my-secret", secret);- when(lambda.getFunction(anyString(), anyString()))+ when(lambda.getFunctionByArn(anyString())).thenThrow(new AwsException("ResourceNotFoundException", "Function not found", 404));assertThrows(AwsException.class, () -> service.rotateSecret("my-secret", TOKEN,diff --git a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerWriteLockTest.java b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerWriteLockTest.javaindex b70a0dc09d..022068e45b 100644--- a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerWriteLockTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerWriteLockTest.java@@ -89,7 +89,7 @@ class SecretsManagerWriteLockTest {@Testvoid deletingASecretWaitsForTheFinalSaveOfARotation() throws Exception {LambdaService lambda = mock(LambdaService.class);- when(lambda.getFunction(anyString(), anyString())).thenReturn(new LambdaFunction());+ when(lambda.getFunctionByArn(anyString())).thenReturn(new LambdaFunction());InvokeResult ok = new InvokeResult();ok.setStatusCode(200);when(lambda.invoke(anyString(), anyString(), any(byte[].class), any())).thenReturn(ok);