Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(ec2): preserve original user-data bytes in instance metadata (#5437)

David Phillipsf4bce302699b
diff --git a/docs/services/ec2.md b/docs/services/ec2.md
index 86b03076c2..e11a8a9de5 100644
--- a/docs/services/ec2.md
+++ b/docs/services/ec2.md
@@ -130,6 +130,8 @@ curl -s -H "x-aws-ec2-metadata-token: $TOKEN" \
As on AWS, the token TTL must be an integer from 1 to 21600 seconds, or the `PUT` returns `400`. A metadata request that presents an unknown or expired token returns `401`, which tells the SDK to fetch a new token. A token is valid only on the instance that requested it: presenting it from another instance returns `401`. A request without a token header still uses IMDSv1; Floci does not enforce `HttpTokens=required`.
+User data is returned as the original base64-decoded bytes, without decompressing gzip content or converting binary data to text. Older records without the original encoding, or records with malformed saved encoding, use their saved UTF-8 text. The response uses `application/octet-stream`, matching the [AWS user-data retrieval contract](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html). Missing or empty data returns `404`; whitespace is preserved. Script execution retains its separate bounded gzip decoding.
+
### Supported IMDS endpoints
| Endpoint | Returns |
@@ -151,7 +153,7 @@ As on AWS, the token TTL must be an integer from 1 to 21600 seconds, or the `PUT
| `GET /latest/meta-data/iam/security-credentials/{role}` | Temporary credentials |
| `GET /latest/meta-data/identity-credentials/ec2/info` | Instance identity role info (`Code`, `LastUpdated`, `AccountId`) |
| `GET /latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance` | Instance identity role credentials |
-| `GET /latest/user-data` | UserData script |
+| `GET /latest/user-data` | Original user-data bytes, including compressed content |
| `GET /latest/dynamic/instance-identity/document` | Identity document JSON |
IAM credentials are served when the instance has an `IamInstanceProfile.Arn` that resolves to an existing instance profile with one role in the profile's account. The role list uses the role name, which can differ from the profile name. Missing profiles, missing roles, and requests for another role return `404`.
diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java
index 97cba956db..600a1e42f9 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java
@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.services.iam.IamService;
import io.github.hectorvent.floci.services.iam.model.IamRole;
import io.github.hectorvent.floci.services.iam.model.SessionCredential;
import io.vertx.core.Vertx;
+import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpServer;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
@@ -23,6 +24,7 @@ import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
+import java.util.Base64;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
@@ -412,14 +414,25 @@ public class Ec2MetadataServer {
if (inst == null) {
return;
}
- String userData = inst.getUserData();
- if (userData == null || userData.isBlank()) {
+ String encoded = inst.getEncodedUserData();
+ byte[] userData;
+ if (encoded != null) {
+ try {
+ userData = encoded.isBlank() ? null : Base64.getDecoder().decode(encoded);
+ } catch (IllegalArgumentException e) {
+ LOG.warnv("Ignoring malformed saved user-data encoding for instance {0}", inst.getInstanceId());
+ userData = inst.getUserData() == null ? null : inst.getUserData().getBytes(StandardCharsets.UTF_8);
+ }
+ } else {
+ userData = inst.getUserData() == null ? null : inst.getUserData().getBytes(StandardCharsets.UTF_8);
+ }
+ if (userData == null || userData.length == 0) {
ctx.response().setStatusCode(404).end();
return;
}
ctx.response().setStatusCode(200)
- .putHeader("content-type", "text/plain")
- .end(userData);
+ .putHeader("content-type", "application/octet-stream")
+ .end(Buffer.buffer(userData));
}
private void handleIdentityDocument(RoutingContext ctx) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataUserDataTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataUserDataTest.java
new file mode 100644
index 0000000000..145da06d0a
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataUserDataTest.java
@@ -0,0 +1,171 @@
+package io.github.hectorvent.floci.services.ec2;
+
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.services.ec2.model.Instance;
+import io.github.hectorvent.floci.testing.MutableClock;
+import io.vertx.core.Vertx;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.net.ServerSocket;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.concurrent.TimeUnit;
+import java.util.zip.GZIPOutputStream;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class Ec2MetadataUserDataTest {
+
+ private static final String TTL_HEADER = "X-aws-ec2-metadata-token-ttl-seconds";
+ private static final String TOKEN_HEADER = "X-aws-ec2-metadata-token";
+ private static final String CALLER_IP = "127.0.0.1";
+
+ private final MutableClock clock = new MutableClock();
+ private final HttpClient client = HttpClient.newHttpClient();
+ private Vertx vertx;
+ private Instance instance;
+ private Ec2MetadataServer server;
+ private String endpoint;
+
+ @BeforeEach
+ void startServer() throws Exception {
+ int port;
+ try (ServerSocket socket = new ServerSocket(0)) {
+ port = socket.getLocalPort();
+ }
+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);
+ when(config.services().ec2().imdsPort()).thenReturn(port);
+ vertx = Vertx.vertx();
+ server = new Ec2MetadataServer(vertx, config, null, clock);
+ server.start().get(10, TimeUnit.SECONDS);
+ endpoint = "http://127.0.0.1:" + port;
+
+ instance = instance("i-0123456789abcdef0");
+ server.registerContainer(CALLER_IP, instance.getInstanceId(), instance);
+ }
+
+ @AfterEach
+ void stopServer() throws Exception {
+ server.stop();
+ vertx.close().toCompletionStage().toCompletableFuture().get(10, TimeUnit.SECONDS);
+ }
+
+ @Test
+ void returnsOriginalBinaryBytes() throws Exception {
+ byte[] original = {0, (byte) 0xff, (byte) 0x80, 10, 13};
+ instance.setEncodedUserData(Base64.getEncoder().encodeToString(original));
+ instance.setUserData("lossy execution text");
+ HttpResponse<byte[]> response = getUserData(null);
+ assertEquals(200, response.statusCode());
+ assertArrayEquals(original, response.body());
+ assertEquals("application/octet-stream", response.headers().firstValue("content-type").orElseThrow());
+ }
+
+ @Test
+ void returnsCompressedBytesWhileExecutionUsesDecodedScript() throws Exception {
+ String script = "#!/bin/sh\necho snow: 雪\n";
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ try (GZIPOutputStream gzip = new GZIPOutputStream(bytes)) {
+ gzip.write(script.getBytes(StandardCharsets.UTF_8));
+ }
+ String encoded = Base64.getEncoder().encodeToString(bytes.toByteArray());
+ instance.setEncodedUserData(encoded);
+ instance.setUserData(Ec2UserDataDecoder.decode(encoded));
+ assertEquals(script, instance.getUserData());
+ String token = putToken("60").body();
+ HttpResponse<byte[]> response = getUserData(token);
+ assertEquals(200, response.statusCode());
+ assertArrayEquals(bytes.toByteArray(), response.body());
+ }
+
+ @Test
+ void returnsLegacyUtf8AndWhitespace() throws Exception {
+ for (String data : new String[]{"雪\n", " \n\t"}) {
+ instance.setUserData(data);
+ HttpResponse<byte[]> response = getUserData(null);
+ assertEquals(200, response.statusCode());
+ assertArrayEquals(
+ data.getBytes(StandardCharsets.UTF_8), response.body());
+ instance.setEncodedUserData(Base64.getEncoder().encodeToString(data.getBytes(StandardCharsets.UTF_8)));
+ HttpResponse<byte[]> encodedResponse = getUserData(null);
+ assertEquals(200, encodedResponse.statusCode());
+ assertArrayEquals(data.getBytes(StandardCharsets.UTF_8), encodedResponse.body());
+ instance.setEncodedUserData(null);
+ }
+ }
+
+ @Test
+ void absentAndEmptyUserDataRemainNotFound() throws Exception {
+ assertEquals(404, getUserData(null).statusCode());
+ instance.setUserData("");
+ assertEquals(404, getUserData(null).statusCode());
+ instance.setUserData("stale text");
+ for (String encoded : new String[]{"", " \n\t"}) {
+ instance.setEncodedUserData(encoded);
+ assertEquals(404, getUserData(null).statusCode());
+ }
+ }
+
+ @Test
+ void alreadyStoredExpandedUserDataIsNotSubjectToTheIngestionLimit() throws Exception {
+ byte[] data = "A".repeat(32 * 1024).getBytes(StandardCharsets.UTF_8);
+ instance.setUserData(new String(data, StandardCharsets.UTF_8));
+ instance.setEncodedUserData(Base64.getEncoder().encodeToString(data));
+ HttpResponse<byte[]> response = getUserData(null);
+ assertEquals(200, response.statusCode());
+ assertArrayEquals(data, response.body());
+ }
+
+ @Test
+ void malformedStoredEncodingFallsBackToSavedText() throws Exception {
+ instance.setEncodedUserData("not-base64!");
+ instance.setUserData("saved text 雪");
+ HttpResponse<byte[]> response = getUserData(null);
+ assertEquals(200, response.statusCode());
+ assertArrayEquals(instance.getUserData().getBytes(StandardCharsets.UTF_8), response.body());
+ }
+
+ @Test
+ void malformedStoredEncodingWithoutSavedTextRemainsNotFound() throws Exception {
+ instance.setEncodedUserData("not-base64!");
+ assertEquals(404, getUserData(null).statusCode());
+ }
+
+ @Test
+ void invalidTokenCannotReadUserData() throws Exception {
+ instance.setUserData("private user data");
+ assertEquals(401, getUserData("invalid-token").statusCode());
+ }
+
+ private HttpResponse<byte[]> getUserData(String token) throws Exception {
+ HttpRequest.Builder request = HttpRequest.newBuilder(URI.create(endpoint + "/latest/user-data"));
+ if (token != null) {
+ request.header(TOKEN_HEADER, token);
+ }
+ return client.send(request.GET().build(), HttpResponse.BodyHandlers.ofByteArray());
+ }
+
+ private static Instance instance(String instanceId) {
+ Instance instance = new Instance();
+ instance.setInstanceId(instanceId);
+ return instance;
+ }
+
+ private HttpResponse<String> putToken(String ttl) throws Exception {
+ return client.send(HttpRequest.newBuilder(URI.create(endpoint + "/latest/api/token"))
+ .header(TTL_HEADER, ttl).PUT(HttpRequest.BodyPublishers.noBody()).build(),
+ HttpResponse.BodyHandlers.ofString());
+ }
+
+}