Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): resolve layer version ARNs by account (#2948)
Brian Taylor24a8c8440bcb
diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex 67a5d6d655..92fab8888c 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -200,13 +200,34 @@ architecture. `Marker` is opaque and signed with a key generated at startup, soedited or previous-run token is rejected with `InvalidParameterValueException` rather thanapplied as a cursor. One divergence: a parameter sent with an empty value(`?CompatibleRuntime=`) is treated as absent rather than rejected, because RESTEasy binds an-empty query value as null. `CreateFunction`/`UpdateFunctionConfiguration`-validate each `Layers` ARN eagerly against that storage, matching real AWS - an unresolvable ARN-is rejected with `InvalidParameterValueException`, not silently accepted. Only resolves layers-published into this same local Floci instance; a real AWS-owned layer ARN (e.g. the AWS AppConfig-Extension or a Datadog-published layer) can never resolve here, since there's no mechanism in-Floci for fetching real AWS content - publish your own copy of the layer's content locally under-a name you control and reference that ARN instead.+empty query value as null. Resolution honours the ARN's+account and partition: an ARN naming another account resolves to nothing rather than to a+same-named layer of the caller's own, matching the live service, which answers that case with+`AccessDeniedException` and never substitutes. `CreateFunction`/`UpdateFunctionConfiguration`+validate each `Layers` ARN in the caller's own account eagerly against that storage, matching+real AWS - an unresolvable one is rejected with `InvalidParameterValueException: Layer version+... does not exist.`, not silently accepted.++An ARN naming another account or another partition is answered on the live service by the layer's+resource policy: an AWS-managed public layer resolves, and everything else is+`AccessDeniedException`. Measured on `CreateFunction` in ap-southeast-1, a foreign-account ARN and+a cross-partition ARN return the same `AccessDeniedException`, so Floci returns that for both.+Floci implements no layer permissions and cannot fetch real AWS content, so it cannot tell a+public layer from a private one; refusing is the faithful default, being the answer AWS gives to+every foreign ARN except a public one.++Set `floci.services.lambda.accept-external-layer-arns: true`+(`FLOCI_SERVICES_LAMBDA_ACCEPT_EXTERNAL_LAYER_ARNS`) to record a same-partition foreign ARN on the+function instead of refusing it, which is what a stack attaching Powertools, the AppConfig+extension or a vendor-published layer needs. The trade is explicit: with it on, Floci also accepts+an ARN AWS would refuse with `AccessDeniedException`, so a typo or a private third-party layer+passes here and fails on deploy. The content is never mounted at `/opt` either way, and a warning+is logged at attach time and again at invoke; publish your own copy of the content locally under a+name you control if the handler needs it at runtime.++A layer ARN outside the `aws` partition is refused whatever that setting says. Partitions are+isolated, so no resource policy can ever make such a layer readable, and `GetLayerVersionByArn`+rejects one outright with `InvalidParameterValueException: Invalid layer version ...`.## Not Implementeddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 2363c6ea03..45d064687c 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -2147,6 +2147,28 @@ public interface EmulatorConfig {*/Optional<List<String>> extraHosts();+ /**+ * Accept a {@code Layers} ARN naming another account, recording it on the function+ * without mounting its content. Off by default, because it broadens what CreateFunction+ * and UpdateFunctionConfiguration accept beyond what AWS does.+ *+ * <p>On the live service a foreign-account layer resolves through its resource policy:+ * an AWS-managed public layer succeeds, and everything else is AccessDeniedException.+ * Floci implements no layer permissions, so it cannot tell those apart. The default+ * answers both the way AWS answers the second, which is the faithful choice for a+ * compatibility layer. Turn this on to attach public layers such as Powertools, the+ * AppConfig extension or a vendor-published layer, at the cost of also accepting an+ * ARN AWS would refuse. The content is never fetched either way, so a function whose+ * behaviour depends on the layer will not run correctly here.+ *+ * <p>A layer ARN outside the {@code aws} partition is rejected regardless: partitions+ * are isolated, so no resource policy can make one readable.+ *+ * Env var: FLOCI_SERVICES_LAMBDA_ACCEPT_EXTERNAL_LAYER_ARNS+ */+ @WithDefault("false")+ boolean acceptExternalLayerArns();+/*** Concurrent executions ceiling applied per region. AWS Lambda's* "account-level" concurrency is in fact a per-region quota (default 1000);diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.javaindex 3757554572..b02ecfd84e 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java@@ -129,6 +129,36 @@ public final class AwsArnUtils {return isArn(value) && value.split(":", 6)[2].equals(service);}+ /**+ * True when the ARN names a partition other than {@code aws}, the only one Floci emulates.+ * An empty partition field is not foreign: callers that omit it are naming a local+ * resource.+ *+ * <p>Deliberately a literal {@code aws} rather than {@link #PARTITION_REGEX}. That constant+ * exists to recognise a legal ARN in any partition; this asks the opposite question, whether+ * the ARN names a partition this emulator can serve, and the answer is only ever the+ * commercial one.+ */+ public static boolean isForeignPartition(Arn arn) {+ if (arn == null) {+ return false;+ }+ String partition = arn.partition();+ return partition != null && !partition.isEmpty() && !"aws".equals(partition);+ }++ /**+ * True when the ARN names an account other than {@code localAccountId}. An empty account+ * field is not foreign: several AWS ARN forms omit it for a resource the caller owns.+ */+ public static boolean isForeignAccount(Arn arn, String localAccountId) {+ if (arn == null) {+ return false;+ }+ String account = arn.accountId();+ return account != null && !account.isEmpty() && !account.equals(localAccountId);+ }+/*** Converts an SQS ARN to a queue URL using the given base URL.* Example: arn:aws:sqs:us-east-1:000000000000:my-queue → http://localhost:4566/000000000000/my-queuediff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.javaindex 527809fc64..f1922d8a6c 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java@@ -454,24 +454,15 @@ public class LambdaLayerService {+ " constraint: Member must satisfy regular expression pattern: "+ LAYER_VERSION_ARN_PATTERN, 400);}- // resolveLayerByArn keys on region/name/version within the caller's own partition, so an- // ARN naming another account would otherwise resolve to the caller's same-named layer.- // No layer here can be shared cross-account (layer permissions are unimplemented), so a- // foreign account is always a miss; this is where sharing would hook in if that changes.- // resolveLayerByArn also drops the partition, so an ARN naming another one would- // otherwise resolve to the local layer under a foreign-partition ARN. Floci emulates- // the aws partition; the live service rejects the others outright.- AwsArnUtils.Arn parsed = AwsArnUtils.parse(layerVersionArn);- if (parsed.partition() != null && !parsed.partition().isEmpty()- && !"aws".equals(parsed.partition())) {+ // Floci emulates the aws partition; the live service rejects the others outright, and+ // with a different error than an unresolvable ARN, so this precedes the lookup.+ if (AwsArnUtils.isForeignPartition(AwsArnUtils.parse(layerVersionArn))) {throw new AwsException("InvalidParameterValueException","Invalid layer version " + layerVersionArn, 400);}- String requestedAccount = AwsArnUtils.accountOrDefault(layerVersionArn, null);- if (requestedAccount != null && !requestedAccount.equals(regionResolver.getAccountId())) {- throw new AwsException("ResourceNotFoundException",- "The resource you requested does not exist.", 404);- }+ // A foreign account is a miss rather than a substitution: resolveLayerByArn scopes the+ // lookup to the caller's own account. This is where cross-account sharing would hook in+ // if layer permissions were ever implemented.LambdaLayerVersion lv = resolveLayerByArn(layerVersionArn);if (lv == null) {throw new AwsException("ResourceNotFoundException",@@ -496,6 +487,9 @@ public class LambdaLayerService {if (resourceParts.length < 3 || !"layer".equals(resourceParts[0])) {return null;}+ if (isForeignLayerArn(arn)) {+ return null;+ }String region = arn.region();String layerName = resourceParts[1];long version;@@ -507,6 +501,52 @@ public class LambdaLayerService {return layerStore.get(region, layerName, version).orElse(null);}+ /**+ * True when the ARN is a well-formed layer version ARN naming an account or partition other+ * than the caller's, so Floci cannot decide whether it exists. On the live service such a+ * layer resolves through its resource policy, measured against ap-southeast-1: an ARN in+ * another account whose name and version match a layer of the caller's own is+ * {@code AccessDeniedException}, never a substitution. Floci has no layer permission model+ * (see the Not Implemented list), so it treats every foreign ARN as unknowable rather than+ * resolving it inside the caller's own partition.+ */+ public boolean isForeignLayerArn(String layerVersionArn) {+ AwsArnUtils.Arn arn = parseLayerVersionArn(layerVersionArn);+ if (arn == null) {+ return false;+ }+ return isForeignLayerArn(arn);+ }++ /**+ * True when the ARN is a well-formed layer version ARN outside the {@code aws} partition.+ * Partitions are isolated, so such a layer is unreachable rather than merely unreadable, and+ * {@link #getLayerVersionByArn} already rejects it outright. Attaching one to a function has+ * to reject too, or Floci would persist an ARN its own lookup path calls invalid.+ */+ public boolean isForeignPartitionLayerArn(String layerVersionArn) {+ return AwsArnUtils.isForeignPartition(parseLayerVersionArn(layerVersionArn));+ }++ private AwsArnUtils.Arn parseLayerVersionArn(String layerVersionArn) {+ AwsArnUtils.Arn arn;+ try {+ arn = AwsArnUtils.parse(layerVersionArn);+ } catch (IllegalArgumentException e) {+ return null;+ }+ String[] resourceParts = arn.resource().split(":");+ if (resourceParts.length < 3 || !"layer".equals(resourceParts[0])) {+ return null;+ }+ return arn;+ }++ private boolean isForeignLayerArn(AwsArnUtils.Arn arn) {+ return AwsArnUtils.isForeignPartition(arn)+ || AwsArnUtils.isForeignAccount(arn, regionResolver.getAccountId());+ }+private byte[] resolveLayerContent(Map<String, Object> content) {String zipFileBase64 = (String) content.get("ZipFile");if (zipFileBase64 != null) {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 aefb357c25..530d73e8d7 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@@ -234,13 +234,42 @@ public class LambdaService implements ResourceProvider {// content mounted, which is correct AWS-parity behavior for a layer deleted *after* being// attached (AWS doesn't re-validate on every invoke either), but was previously the only// signal at all for a bad ARN, even a typo caught at attach time on real AWS.+ //+ // An ARN naming another account or another partition is answered on the live service by the+ // layer's resource policy: a public layer resolves, and everything else is+ // AccessDeniedException. Measured on CreateFunction in ap-southeast-1, a foreign-account ARN+ // and a cross-partition ARN return the same AccessDeniedException, so Floci returns that for+ // both rather than inventing a distinction the API does not make.+ //+ // Floci implements no layer permissions, so it cannot tell a public layer from a private one+ // and cannot fetch either one's content. Refusing is the faithful default: it is the answer+ // AWS gives to every foreign ARN except a public layer. floci.services.lambda+ // .accept-external-layer-arns records a same-partition foreign ARN unresolved instead, which+ // is what a stack attaching Powertools or the AppConfig extension needs. Cross-partition+ // stays refused even then, because partitions are isolated and no policy can reach across+ // one, and because GetLayerVersionByArn already calls such an ARN invalid.private void validateLayersResolvable(List<String> layerArns) {if (layerArns == null || layerService == null) return;for (String arn : layerArns) {- if (layerService.resolveLayerByArn(arn) == null) {- throw new AwsException("InvalidParameterValueException",- "Layer version " + arn + " does not exist.", 400);+ if (layerService.resolveLayerByArn(arn) != null) {+ continue;+ }+ if (layerService.isForeignLayerArn(arn)) {+ boolean acceptable = !layerService.isForeignPartitionLayerArn(arn)+ && config != null+ && config.services().lambda().acceptExternalLayerArns();+ if (!acceptable) {+ throw new AwsException("AccessDeniedException",+ "User is not authorized to perform: lambda:GetLayerVersion on resource: "+ + arn + " because no resource-based policy allows the"+ + " lambda:GetLayerVersion action", 403);+ }+ LOG.warnv("Layer {0} belongs to another account; recorded on the function but its"+ + " content will not be mounted at /opt", arn);+ continue;}+ throw new AwsException("InvalidParameterValueException",+ "Layer version " + arn + " does not exist.", 400);}}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex c46f56654a..d8c76b39be 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -291,6 +291,7 @@ floci:container-idle-timeout-seconds: 300region-concurrency-limit: 1000unreserved-concurrency-min: 100+ accept-external-layer-arns: false # FLOCI_SERVICES_LAMBDA_ACCEPT_EXTERNAL_LAYER_ARNS - accept a Layers ARN from another account (content is never mounted). AWS answers these through the layer resource policy, which Floci does not model, so the default refuses them like AWS refuses a non-public one. Turn on to attach public layers such as Powertools.# aws-config-path: # Host path to bind-mount (read-only) at /opt/aws-config for real credential discovery# extra-hosts: # Extra /etc/hosts entries for Lambda containers, "hostname:ip" ("host-gateway" allowed as ip)# container-name-prefix: floci # FLOCI_SERVICES_LAMBDA_CONTAINER_NAME_PREFIX — base name prefix for spawned containers and code volumes ([A-Za-z0-9][A-Za-z0-9_.-]*; invalid values fall back to "floci")diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsArnOwnershipTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsArnOwnershipTest.javanew file mode 100644index 0000000000..d5a1c0c6ae--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsArnOwnershipTest.java@@ -0,0 +1,64 @@+package io.github.hectorvent.floci.core.common;++import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Ownership predicates for a parsed ARN. Both are generic on purpose: RdsService already carries+ * its own copy of the same two checks inside targetGroupBelongsTo, and Lambda layer resolution+ * needs them too, so the resource-shaped part stays with the caller and only these live here.+ */+class AwsArnOwnershipTest {++ private static final String LOCAL = "000000000000";++ private static AwsArnUtils.Arn arn(String value) {+ return AwsArnUtils.parse(value);+ }++ @Test+ void awsPartitionIsNotForeign() {+ assertFalse(AwsArnUtils.isForeignPartition(+ arn("arn:aws:lambda:us-east-1:000000000000:layer:l:1")));+ }++ @Test+ void otherPartitionsAreForeign() {+ assertTrue(AwsArnUtils.isForeignPartition(+ arn("arn:aws-cn:lambda:cn-north-1:000000000000:layer:l:1")));+ assertTrue(AwsArnUtils.isForeignPartition(+ arn("arn:aws-us-gov:lambda:us-gov-west-1:000000000000:layer:l:1")));+ }++ @Test+ void anEmptyPartitionIsNotForeign() {+ assertFalse(AwsArnUtils.isForeignPartition(arn("arn::lambda:us-east-1:000000000000:layer:l:1")));+ }++ @Test+ void theCallersOwnAccountIsNotForeign() {+ assertFalse(AwsArnUtils.isForeignAccount(+ arn("arn:aws:lambda:us-east-1:000000000000:layer:l:1"), LOCAL));+ }++ @Test+ void anotherAccountIsForeign() {+ assertTrue(AwsArnUtils.isForeignAccount(+ arn("arn:aws:lambda:us-east-1:017000801446:layer:l:1"), LOCAL));+ }++ @Test+ void anEmptyAccountIsNotForeign() {+ // AWS-managed layers use arn:aws:lambda:::awslayer:<name>, which names no account and is+ // not somebody else's resource.+ assertFalse(AwsArnUtils.isForeignAccount(arn("arn:aws:lambda:::awslayer:AWSLambda-Python"), LOCAL));+ }++ @Test+ void nullIsNotForeign() {+ assertFalse(AwsArnUtils.isForeignPartition(null));+ assertFalse(AwsArnUtils.isForeignAccount(null, LOCAL));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaExternalLayerArnAcceptedIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaExternalLayerArnAcceptedIntegrationTest.javanew file mode 100644index 0000000000..c79c8c585b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaExternalLayerArnAcceptedIntegrationTest.java@@ -0,0 +1,157 @@+package io.github.hectorvent.floci.services.lambda;++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.io.ByteArrayOutputStream;+import java.util.Base64;+import java.util.Map;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;++/**+ * {@code floci.services.lambda.accept-external-layer-arns} turned on.+ *+ * <p>The default refuses every foreign-account layer ARN, because Floci has no layer permission+ * model and so cannot tell an AWS-managed public layer from a private one that AWS would refuse.+ * A stack attaching Powertools, the AppConfig extension or a vendor-published layer needs the+ * permissive answer, which is what this flag selects: the ARN is recorded verbatim and its+ * content is never mounted.+ *+ * <p>Cross-partition stays refused even here. Partitions are isolated, so no resource policy can+ * make an {@code aws-cn} layer readable from {@code aws}, and {@code GetLayerVersionByArn} calls+ * such an ARN invalid outright.+ */+@QuarkusTest+@TestProfile(LambdaExternalLayerArnAcceptedIntegrationTest.AcceptExternalLayerArnsProfile.class)+class LambdaExternalLayerArnAcceptedIntegrationTest {++ private static final String POWERTOOLS_ARN =+ "arn:aws:lambda:us-east-1:017000801446:layer:AWSLambdaPowertoolsPythonV3-python313-arm64:36";++ private static String zipBase64(String path, String content) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ zos.putNextEntry(new ZipEntry(path));+ zos.write(content.getBytes());+ zos.closeEntry();+ }+ return Base64.getEncoder().encodeToString(baos.toByteArray());+ }++ private static void createFunction(String name, String layerArn, int expectedStatus) throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r",+ "Handler": "handler.handler",+ "Code": { "ZipFile": "%s" },+ "Layers": ["%s"]+ }+ """.formatted(name, zipBase64("handler.py", "def handler(e, c): return {}"), layerArn))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(expectedStatus);+ }++ @Test+ void awsManagedLayerArnIsAcceptedAndEchoedVerbatim() throws Exception {+ createFunction("ext-layer-managed", POWERTOOLS_ARN, 201);++ given()+ .when()+ .get("/2015-03-31/functions/ext-layer-managed")+ .then()+ .statusCode(200)+ .body("Configuration.Layers", hasSize(1))+ .body("Configuration.Layers[0].Arn", equalTo(POWERTOOLS_ARN));++ given()+ .when()+ .delete("/2015-03-31/functions/ext-layer-managed")+ .then()+ .statusCode(204);+ }++ @Test+ void updateFunctionConfigurationAcceptsAForeignAccountArn() throws Exception {+ createFunction("ext-layer-update", POWERTOOLS_ARN, 201);++ String other = "arn:aws:lambda:us-east-1:017000801446:layer:AWSLambdaPowertoolsPythonV3-python313-arm64:37";+ given()+ .contentType("application/json")+ .body("""+ {+ "Layers": ["%s"]+ }+ """.formatted(other))+ .when()+ .put("/2015-03-31/functions/ext-layer-update/configuration")+ .then()+ .statusCode(200)+ .body("Layers", hasSize(1))+ .body("Layers[0].Arn", equalTo(other));++ given()+ .when()+ .delete("/2015-03-31/functions/ext-layer-update")+ .then()+ .statusCode(204);+ }++ @Test+ void foreignPartitionArnIsStillRejected() throws Exception {+ createFunction("ext-layer-foreign-partition",+ "arn:aws-cn:lambda:cn-north-1:123456789012:layer:probe:1", 403);++ given()+ .when()+ .get("/2015-03-31/functions/ext-layer-foreign-partition")+ .then()+ .statusCode(404);+ }++ @Test+ void missingLayerInTheCallersOwnAccountIsStillRejected() throws Exception {+ // The flag only relaxes foreign ARNs. A typo in the caller's own account is still the+ // eager InvalidParameterValueException AWS gives, which is the case #2813 relies on.+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "ext-layer-typo",+ "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r",+ "Handler": "handler.handler",+ "Code": { "ZipFile": "%s" },+ "Layers": ["arn:aws:lambda:us-east-1:000000000000:layer:no-such-layer:1"]+ }+ """.formatted(zipBase64("handler.py", "def handler(e, c): return {}")))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"));+ }++ public static final class AcceptExternalLayerArnsProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.services.lambda.accept-external-layer-arns", "true",+ "quarkus.http.test-port", "4588",+ "floci.port", "4588",+ "floci.base-url", "http://localhost:4588");+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerArnAccountIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerArnAccountIntegrationTest.javanew file mode 100644index 0000000000..5a90efc906--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerArnAccountIntegrationTest.java@@ -0,0 +1,242 @@+package io.github.hectorvent.floci.services.lambda;++import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.io.ByteArrayOutputStream;+import java.util.Base64;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;++/**+ * Layer version ARNs carry an account, and resolution has to honour it.+ *+ * <p>Measured against the live service in ap-southeast-1. An ARN in another account whose layer+ * name and version match one of the caller's own is {@code AccessDeniedException}, never a+ * substitution; a cross-partition ARN is the same {@code AccessDeniedException}; and only a+ * missing layer in the caller's own account is+ * {@code InvalidParameterValueException: Layer version ... does not exist.}+ *+ * <p>This class covers the default configuration, which answers every foreign ARN the way AWS+ * answers a non-public one. {@code floci.services.lambda.accept-external-layer-arns} relaxes that+ * for same-partition ARNs, covered by {@link LambdaExternalLayerArnAcceptedIntegrationTest}.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class LambdaLayerArnAccountIntegrationTest {++ private static final String LAYER_NAME = "arn-account-layer";+ private static final String LOCAL_ACCOUNT = "000000000000";+ private static final String FOREIGN_ACCOUNT = "017000801446";+ private static final String POWERTOOLS_ARN =+ "arn:aws:lambda:us-east-1:017000801446:layer:AWSLambdaPowertoolsPythonV3-python313-arm64:36";++ @Inject+ LambdaLayerService layerService;++ private static String zipBase64(String path, String content) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ zos.putNextEntry(new ZipEntry(path));+ zos.write(content.getBytes());+ zos.closeEntry();+ }+ return Base64.getEncoder().encodeToString(baos.toByteArray());+ }++ private static String publishLayer() throws Exception {+ return given()+ .contentType("application/json")+ .body("""+ {+ "Content": { "ZipFile": "%s" },+ "CompatibleRuntimes": ["python3.12"]+ }+ """.formatted(zipBase64("python/shared.py", "VALUE = 1")))+ .when()+ .post("/2018-10-31/layers/" + LAYER_NAME + "/versions")+ .then()+ .statusCode(201)+ .extract().path("LayerVersionArn");+ }++ private static void createFunction(String name, String layerArn, int expectedStatus) throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r",+ "Handler": "handler.handler",+ "Code": { "ZipFile": "%s" },+ "Layers": ["%s"]+ }+ """.formatted(name, zipBase64("handler.py", "def handler(e, c): return {}"), layerArn))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(expectedStatus);+ }++ @Test+ @Order(1)+ void foreignAccountArnDoesNotResolveToTheCallersOwnSameNamedLayer() throws Exception {+ String ownArn = publishLayer();+ assertNotNull(layerService.resolveLayerByArn(ownArn),+ "the caller's own layer must still resolve by its own ARN");++ String foreignArn = ownArn.replace(":" + LOCAL_ACCOUNT + ":", ":" + FOREIGN_ACCOUNT + ":");+ assertNull(layerService.resolveLayerByArn(foreignArn),+ "an ARN naming another account must not resolve to the caller's same-named layer");+ }++ @Test+ @Order(2)+ void foreignPartitionArnDoesNotResolveToTheLocalLayer() throws Exception {+ String ownArn = publishLayer();++ assertNull(layerService.resolveLayerByArn(ownArn.replace("arn:aws:", "arn:aws-cn:")),+ "an ARN in another partition must not resolve to the local layer");+ }++ @Test+ @Order(2)+ void foreignPartitionArnIsRejectedWhenAttachedToAFunction() throws Exception {+ // The live probe returns AccessDeniedException for a cross-partition ARN, identical to+ // the foreign-account case, so this reports what was measured rather than reusing+ // GetLayerVersionByArn's InvalidParameterValueException. Nothing is persisted either way.+ String arn = "arn:aws-cn:lambda:cn-north-1:123456789012:layer:probe:1";+ createFunction("arn-account-foreign-partition", arn, 403);++ given()+ .when()+ .get("/2015-03-31/functions/arn-account-foreign-partition")+ .then()+ .statusCode(404);+ }++ @Test+ @Order(3)+ void foreignAccountArnIsDeniedByDefaultAndTheFunctionIsNotCreated() throws Exception {+ // Floci cannot tell a public layer from a private one without a layer permission model,+ // so the default gives the answer AWS gives to everything but a public layer.+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "arn-account-managed",+ "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r",+ "Handler": "handler.handler",+ "Code": { "ZipFile": "%s" },+ "Layers": ["%s"]+ }+ """.formatted(zipBase64("handler.py", "def handler(e, c): return {}"), POWERTOOLS_ARN))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(403)+ .body("__type", equalTo("AccessDeniedException"))+ .body("message", equalTo(+ "User is not authorized to perform: lambda:GetLayerVersion on resource: "+ + POWERTOOLS_ARN + " because no resource-based policy allows the"+ + " lambda:GetLayerVersion action"));++ given()+ .when()+ .get("/2015-03-31/functions/arn-account-managed")+ .then()+ .statusCode(404);+ }++ @Test+ @Order(4)+ void missingLayerInTheCallersOwnAccountIsStillRejected() throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "arn-account-typo",+ "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r",+ "Handler": "handler.handler",+ "Code": { "ZipFile": "%s" },+ "Layers": ["arn:aws:lambda:us-east-1:000000000000:layer:no-such-layer:1"]+ }+ """.formatted(zipBase64("handler.py", "def handler(e, c): return {}")))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", equalTo(+ "Layer version arn:aws:lambda:us-east-1:000000000000:layer:no-such-layer:1"+ + " does not exist."));+ }++ @Test+ @Order(5)+ void updateFunctionConfigurationIsDeniedAndLeavesTheExistingLayerInPlace() throws Exception {+ String ownArn = publishLayer();+ createFunction("arn-account-update", ownArn, 201);++ given()+ .contentType("application/json")+ .body("""+ {+ "Layers": ["%s"]+ }+ """.formatted(POWERTOOLS_ARN))+ .when()+ .put("/2015-03-31/functions/arn-account-update/configuration")+ .then()+ .statusCode(403)+ .body("__type", equalTo("AccessDeniedException"));++ // A refused update must not have partially applied: the original layer is still attached.+ given()+ .when()+ .get("/2015-03-31/functions/arn-account-update")+ .then()+ .statusCode(200)+ .body("Configuration.Layers", hasSize(1))+ .body("Configuration.Layers[0].Arn", equalTo(ownArn));++ given()+ .when()+ .delete("/2015-03-31/functions/arn-account-update")+ .then()+ .statusCode(204);+ }++ // Cleanup: every version this class published, so a sibling class sees no leftovers.+ @Test+ @Order(20)+ void cleanup_deleteLayerVersions() {+ for (int version = 1; version <= 3; version++) {+ given()+ .when()+ .delete("/2018-10-31/layers/" + LAYER_NAME + "/versions/" + version)+ .then()+ .statusCode(204);+ }++ given()+ .when()+ .get("/2018-10-31/layers/" + LAYER_NAME + "/versions")+ .then()+ .statusCode(200)+ .body("LayerVersions", hasSize(0));+ }+}