Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eks): enable IMDS and link-local metadata access from pod network (#4039)
Simone Primarosa31a19df6f502
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex b73c1ac6a8..916d307424 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -400,12 +400,15 @@ curl -s -H "x-aws-ec2-metadata-token: $TOKEN" \The link-local proxy attaches to the loopback interface of the k3s container network namespace (the node network namespace).- **Reachable from node network namespace:** Workloads configured with `hostNetwork: true` share the node network namespace and can reach `169.254.169.254:80`. This allows local testing of host-network security policies, intrusion-detection rules, and credential exfiltration defenses.-- **Not reachable from ordinary pods:** Pods running in separate pod network namespaces cannot reach `169.254.169.254` through this loopback alias because link-local addresses are non-routable across network namespaces. Pod-CIDR DNAT routing is not implemented.+- **Default isolation for ordinary pods:** By default, pods running in separate pod network namespaces cannot reach `169.254.169.254`. CNI portmap rules on the node intercept local traffic, preserving node credential isolation for multi-tenant or untrusted workloads.+- **Opt-in pod network routing:** When `floci.services.eks.imds-pod-network=true` is set alongside `floci.services.eks.imds=true`, iptables DNAT rules are programmed in a custom `FLOCI-LINK-LOCAL` chain at the head of `PREROUTING`. Traffic originating from the pod CIDR (`10.42.0.0/16`) targeting `169.254.169.254:80` matches first and is routed directly to the local node listener, preempting CNI portmap rules. This enables standard AWS SDK credential resolution inside ordinary pods without requiring `hostNetwork: true`.### ConfigurationIMDS proxy initialization is disabled by default (`floci.services.eks.imds=false`). Set `FLOCI_SERVICES_EKS_IMDS=true` to enable the proxy setup inside the k3s container.+Pod network reachability is also disabled by default (`floci.services.eks.imds-pod-network=false`) to maintain pod isolation. Set `FLOCI_SERVICES_EKS_IMDS_POD_NETWORK=true` together with `FLOCI_SERVICES_EKS_IMDS=true` to route pod traffic to the link-local proxy.+A failure to configure the proxy (for example on custom minimal images lacking network utilities) logs a warning and allows cluster startup to continue.### Hop limitsdiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 5c8c72383c..f5fd5beb6d 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -2871,6 +2871,13 @@ public interface EmulatorConfig {@WithDefault("false")boolean imds();+ /**+ * When true, routes link-local IMDS traffic from ordinary pod network namespaces to the node's+ * link-local listener. Requires {@code imds()} to be enabled.+ */+ @WithDefault("false")+ boolean imdsPodNetwork();+/*** When true, configures k3s with the cluster's per-cluster OIDC signing keypair and* advertises Floci's OIDC issuer URL, enabling in-cluster IAM Roles for Service Accounts (IRSA).diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.javaindex 070dae1882..94308e2adc 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java@@ -1057,6 +1057,10 @@ public class EksClusterManager {return;}+ if (config.services().eks().imdsPodNetwork()) {+ configurePodNetworkRouting(cluster, containerId);+ }+LOG.infov("Configured link-local IMDS endpoint for EKS cluster {0}", cluster.getName());} catch (Exception e) {LOG.warnv("Could not configure link-local IMDS endpoint for EKS cluster {0}: {1}",@@ -1064,6 +1068,26 @@ public class EksClusterManager {}}+ void configurePodNetworkRouting(Cluster cluster, String containerId) {+ configurePodNetworkRouting(cluster, containerId, EksPodNetworkRouting.DEFAULT_ENDPOINTS);+ }++ void configurePodNetworkRouting(Cluster cluster, String containerId, List<LinkLocalEndpoint> endpoints) {+ try {+ String[] routingCmd = EksPodNetworkRouting.buildRoutingCommand(+ EksPodNetworkRouting.DEFAULT_POD_CIDR,+ endpoints);+ ContainerExecResult routing = execInContainerForResult(containerId, routingCmd, 15);+ if (routing.exitCode() != 0) {+ LOG.warnv("Could not configure link-local pod network routing for EKS cluster {0}: {1}",+ cluster.getName(), routing.summary());+ }+ } catch (Exception e) {+ LOG.warnv("Could not configure link-local pod network routing for EKS cluster {0}: {1}",+ cluster.getName(), e.getMessage());+ }+ }+void unregisterMetadataEndpoint(Cluster cluster) {Instance nodeInstance = clusterNodeInstances.remove(clusterResourceName(cluster));if (metadataServer != null && nodeInstance != null) {diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRouting.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRouting.javanew file mode 100644index 0000000000..a9234590f8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRouting.java@@ -0,0 +1,59 @@+package io.github.hectorvent.floci.services.eks;++import java.util.ArrayList;+import java.util.List;++/**+ * Generates iptables routing rules for link-local endpoints inside an EKS cluster container.+ * <p>+ * Programs DNAT rules in the node network namespace nat table so traffic originating+ * from the cluster pod CIDR directed at link-local addresses (such as IMDS 169.254.169.254:80+ * and EKS Pod Identity 169.254.170.23:80) reaches Floci's node listener rather than being+ * dropped by the Linux kernel or hijacked by CNI hostPort ingress rules.+ */+public final class EksPodNetworkRouting {++ public static final String DEFAULT_POD_CIDR = "10.42.0.0/16";+ public static final String CHAIN_NAME = "FLOCI-LINK-LOCAL";+ public static final LinkLocalEndpoint IMDS_ENDPOINT = new LinkLocalEndpoint("169.254.169.254", 80);+ public static final List<LinkLocalEndpoint> DEFAULT_ENDPOINTS = List.of(IMDS_ENDPOINT);++ private EksPodNetworkRouting() {}++ /**+ * Builds a POSIX sh command array that idempotently programs iptables DNAT rules+ * in the node container nat table for the specified link-local endpoints.+ *+ * @param podCidr pod network CIDR (defaults to {@link #DEFAULT_POD_CIDR} if null or blank)+ * @param endpoints link-local endpoints to route from the pod network+ * @return command array suitable for container exec (["sh", "-c", "..."])+ */+ public static String[] buildRoutingCommand(String podCidr, List<LinkLocalEndpoint> endpoints) {+ String cidr = (podCidr != null && !podCidr.isBlank()) ? podCidr : DEFAULT_POD_CIDR;+ if (endpoints == null || endpoints.isEmpty()) {+ throw new IllegalArgumentException("endpoints cannot be null or empty");+ }++ List<String> lines = new ArrayList<>();+ lines.add("set -eu");+ lines.add("IPTABLES=$(command -v iptables 2>/dev/null || command -v /bin/aux/iptables 2>/dev/null || true)");+ lines.add("if [ -z \"$IPTABLES\" ]; then");+ lines.add(" echo 'iptables not found in container' >&2");+ lines.add(" exit 1");+ lines.add("fi");+ lines.add("$IPTABLES -t nat -N " + CHAIN_NAME + " 2>/dev/null || true");+ lines.add("$IPTABLES -t nat -C PREROUTING -j " + CHAIN_NAME + " 2>/dev/null || $IPTABLES -t nat -I PREROUTING 1 -j " + CHAIN_NAME);++ for (LinkLocalEndpoint ep : endpoints) {+ String check = String.format(+ "$IPTABLES -t nat -C %s -s %s -d %s -p tcp --dport %d -j DNAT --to-destination %s:%d 2>/dev/null",+ CHAIN_NAME, cidr, ep.ip(), ep.port(), ep.ip(), ep.port());+ String add = String.format(+ "$IPTABLES -t nat -A %s -s %s -d %s -p tcp --dport %d -j DNAT --to-destination %s:%d",+ CHAIN_NAME, cidr, ep.ip(), ep.port(), ep.ip(), ep.port());+ lines.add(check + " || " + add);+ }++ return new String[]{"sh", "-c", String.join("\n", lines)};+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/LinkLocalEndpoint.java b/src/main/java/io/github/hectorvent/floci/services/eks/LinkLocalEndpoint.javanew file mode 100644index 0000000000..48d2091a85--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/LinkLocalEndpoint.java@@ -0,0 +1,49 @@+package io.github.hectorvent.floci.services.eks;++import java.util.Objects;++/**+ * Represents a link-local network endpoint (IP address and TCP port)+ * routed from pod network namespaces to local node listeners.+ */+public record LinkLocalEndpoint(String ip, int port) {++ public LinkLocalEndpoint {+ Objects.requireNonNull(ip, "ip cannot be null");+ if (ip.isBlank()) {+ throw new IllegalArgumentException("ip cannot be blank");+ }+ if (!isValidIpv4Literal(ip.trim())) {+ throw new IllegalArgumentException("ip must be a valid IPv4 address literal: " + ip);+ }+ if (port <= 0 || port > 65535) {+ throw new IllegalArgumentException("port must be between 1 and 65535");+ }+ ip = ip.trim();+ }++ private static boolean isValidIpv4Literal(String ip) {+ String[] parts = ip.split("\\.", -1);+ if (parts.length != 4) {+ return false;+ }+ for (String part : parts) {+ if (part.isEmpty() || part.length() > 3) {+ return false;+ }+ for (int i = 0; i < part.length(); i++) {+ if (!Character.isDigit(part.charAt(i))) {+ return false;+ }+ }+ int val = Integer.parseInt(part);+ if (val < 0 || val > 255) {+ return false;+ }+ if (part.length() > 1 && part.startsWith("0")) {+ return false;+ }+ }+ return true;+ }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 736b909aff..9fd286fcec 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -602,6 +602,7 @@ floci:ecr-registry-mirror: true # inject a registries.yaml so pods can pull images pushed to Floci ECRdisable-cni: false # start k3s without its bundled flannel/kube-proxy so a real CNI (e.g. Cilium) can take overimds: false # expose link-local IMDS (169.254.169.254) inside the cluster container+ imds-pod-network: false # route link-local IMDS traffic from ordinary pod network namespaces (requires imds: true)irsa-signing-key: true # sign k3s service account tokens with the cluster OIDC keymwaa:enabled: truediff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.javaindex ce52ad3a3d..f5f6c72946 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java@@ -775,6 +775,7 @@ class EksClusterManagerTest {manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");verify(metadataServer).reconcileContainerAddresses(any(), any());+ // imds=true, imdsPodNetwork=false (default): 2 commands (install probe, start proxy)assertEquals(2, capturedCmds.size());// First command: install probeassertTrue(capturedCmds.get(0)[2].contains("command -v socat"));@@ -785,9 +786,34 @@ class EksClusterManagerTest {assertNotNull(manager.getRegisteredClusterNodeInstance(cluster));}+ @Test+ void configuresPodNetworkRoutingWhenImdsPodNetworkEnabled() {+ when(eks.imdsPodNetwork()).thenReturn(true);++ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");++ verify(metadataServer).reconcileContainerAddresses(any(), any());+ assertEquals(3, capturedCmds.size());+ // First command: install probe+ assertTrue(capturedCmds.get(0)[2].contains("command -v socat"));+ // Second command: start command with 169.254.169.254+ assertTrue(capturedCmds.get(1)[2].contains("169.254.169.254"));+ assertTrue(capturedCmds.get(1)[2].contains("TCP:floci-host:9169"));+ // Third command: pod network routing with iptables+ assertTrue(capturedCmds.get(2)[2].contains("FLOCI-LINK-LOCAL"));+ assertTrue(capturedCmds.get(2)[2].contains("10.42.0.0/16"));+ assertTrue(capturedCmds.get(2)[2].contains("169.254.169.254"));++ assertNotNull(manager.getRegisteredClusterNodeInstance(cluster));+ }+@Testvoid skipsWhenImdsIsDisabled() {when(eks.imds()).thenReturn(false);+ when(eks.imdsPodNetwork()).thenReturn(true);Cluster cluster = new Cluster();cluster.setName("test-cluster");@@ -810,6 +836,27 @@ class EksClusterManagerTest {manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");}+ @Test+ void podNetworkRoutingFailureLogsWarningAndDoesNotAbort() {+ when(eks.imdsPodNetwork()).thenReturn(true);++ InspectExecCmd inspectExec = Mockito.mock(InspectExecCmd.class);+ InspectExecResponse inspectResponse = Mockito.mock(InspectExecResponse.class);+ // Simulate install and start succeeding (0), but routing failing (1)+ when(inspectResponse.getExitCodeLong()).thenReturn(0L, 0L, 1L);+ when(inspectExec.exec()).thenReturn(inspectResponse);+ when(dockerClient.inspectExecCmd(anyString())).thenReturn(inspectExec);++ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ // Pod network routing failure logs warning and continues without throwing+ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");++ assertEquals(3, capturedCmds.size());+ assertNotNull(manager.getRegisteredClusterNodeInstance(cluster));+ }+@Testvoid unregisterMetadataEndpointRemovesInstance() {Cluster cluster = new Cluster();diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.javaindex e9a7361848..afb55bfdc1 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.java@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import io.github.hectorvent.floci.core.common.docker.DockerHostResolver;import io.github.hectorvent.floci.services.ec2.Ec2MetadataServer;import io.github.hectorvent.floci.services.eks.model.Cluster;import io.quarkus.test.junit.QuarkusTest;@@ -38,7 +39,9 @@ class EksImdsDockerIntegrationTest {public static final class Profile implements QuarkusTestProfile {@Overridepublic Map<String, String> getConfigOverrides() {- return Map.of("floci.services.eks.imds", "true");+ return Map.of(+ "floci.services.eks.imds", "true",+ "floci.services.eks.imds-pod-network", "true");}}@@ -63,6 +66,9 @@ class EksImdsDockerIntegrationTest {@InjectEksClusterManager eksClusterManager;+ @Inject+ DockerHostResolver dockerHostResolver;+private String containerId;private Cluster cluster;@@ -73,6 +79,8 @@ class EksImdsDockerIntegrationTest {LOG.warn("Docker daemon is not available; skipping EksImdsDockerIntegrationTest");}Assumptions.assumeTrue(dockerAvailable, "Docker daemon must be available for EKS IMDS integration test");+ Assumptions.assumeTrue(dockerHostResolver.isLinuxHost(),+ "Link-local IMDS container test requires a Linux host; on macOS/Windows, container-to-host proxy traffic arrives from 127.0.0.1 which collides across clusters");metadataServer.start().join();}@@ -106,9 +114,9 @@ class EksImdsDockerIntegrationTest {containerId = lifecycleManager.createAndStart(spec).containerId();assertNotNull(containerId, "Container ID must not be null");- // Ensure curl dependency is installed in the test fixture if absent+ // Ensure curl, iptables, and iproute2 dependencies are installed in the test fixture if absentexecInContainer(containerId, new String[]{"sh", "-c",- "command -v curl >/dev/null 2>&1 || apk add --no-cache curl"});+ "command -v curl >/dev/null 2>&1 && command -v iptables >/dev/null 2>&1 && command -v ip >/dev/null 2>&1 || apk add --no-cache curl iptables iproute2"});eksClusterManager.configureLinkLocalMetadataEndpoint(cluster, containerId);@@ -124,26 +132,78 @@ class EksImdsDockerIntegrationTest {assertNotNull(instanceId, "instance-id response should not be null");assertTrue(instanceId.trim().startsWith("i-"), "Instance ID should start with 'i-': " + instanceId);- // IMDSv1 fallback test using wget (tool guaranteed by alpine:3.21 image)+ // IMDSv1 fallback test using wget (hostNetwork / node namespace regression test)String imdsv1Cmd = "wget -q -O - http://169.254.169.254/latest/meta-data/instance-id";String v1InstanceId = execInContainer(containerId, new String[]{"sh", "-c", imdsv1Cmd});assertEquals(instanceId.trim(), v1InstanceId.trim(), "IMDSv1 and IMDSv2 instance IDs should match");- // Pod-isolation test: ordinary pods in their own network namespace cannot reach link-local IMDS- // Tested using wget (tool guaranteed by alpine:3.21 image)- String podIsolationCmd = """- if command -v unshare >/dev/null 2>&1; then- unshare -n wget -q -O - -T 2 http://169.254.169.254/latest/meta-data/instance-id- else- ip netns add pod-test 2>/dev/null || true- ip netns exec pod-test wget -q -O - -T 2 http://169.254.169.254/latest/meta-data/instance-id- ret=$?- ip netns del pod-test 2>/dev/null || true- exit $ret- fi+ // Pod network namespace test: ordinary pods in their own network namespace reach link-local IMDS+ // via the rules programmed for the pod CIDR (10.42.0.0/16).+ String podNetworkSetupCmd = """+ set -e+ ip link add cni0 type bridge 2>/dev/null || true+ ip addr add 10.42.0.1/24 dev cni0 2>/dev/null || true+ ip link set cni0 up++ ip netns add pod-test 2>/dev/null || true+ ip link add veth-host type veth peer name eth0 netns pod-test 2>/dev/null || true+ ip link set veth-host master cni0 up+ ip netns exec pod-test ip link set lo up+ ip netns exec pod-test ip addr add 10.42.0.15/24 dev eth0 2>/dev/null || true+ ip netns exec pod-test ip link set eth0 up+ ip netns exec pod-test ip route replace default via 10.42.0.1++ # Stand-in CNI portmap rule: k3s/flannel installs CNI-HOSTPORT-DNAT matching dst-type LOCAL.+ # Simulate a hostPort/ingress binding or redirect on port 80 that intercepts LOCAL traffic.+ iptables -t nat -N CNI-HOSTPORT-DNAT 2>/dev/null || true+ iptables -t nat -F CNI-HOSTPORT-DNAT 2>/dev/null || true+ iptables -t nat -A CNI-HOSTPORT-DNAT -p tcp --dport 80 -j REDIRECT --to-ports 9999+ iptables -t nat -D PREROUTING -m addrtype --dst-type LOCAL -j CNI-HOSTPORT-DNAT 2>/dev/null || true+ iptables -t nat -A PREROUTING -m addrtype --dst-type LOCAL -j CNI-HOSTPORT-DNAT""";- ExecResult podResult = execInContainerWithExitCode(containerId, new String[]{"sh", "-c", podIsolationCmd});- assertNotEquals(0L, podResult.exitCode(), "IMDS should not be reachable from an isolated pod network namespace");+ execInContainer(containerId, new String[]{"sh", "-c", podNetworkSetupCmd});++ try {+ // Ordinary pod querying instance-id with FLOCI-LINK-LOCAL preempting CNI-HOSTPORT-DNAT+ String podInstanceIdCmd = "ip netns exec pod-test wget -q -O - -T 3 http://169.254.169.254/latest/meta-data/instance-id";+ String podInstanceId = execInContainer(containerId, new String[]{"sh", "-c", podInstanceIdCmd});+ assertNotNull(podInstanceId, "Pod instance ID response should not be null");+ assertEquals(instanceId.trim(), podInstanceId.trim(),+ "Pod should receive the same instance ID as the node namespace");++ // Ordinary pod querying IAM info+ String podIamInfoCmd = "ip netns exec pod-test wget -q -O - -T 3 http://169.254.169.254/latest/meta-data/iam/info";+ String podIamInfo = execInContainer(containerId, new String[]{"sh", "-c", podIamInfoCmd});+ assertNotNull(podIamInfo, "Pod IAM info response should not be null");+ assertTrue(podIamInfo.contains(clusterName + "-node-profile"),+ "Pod IAM info should contain instance profile: " + podIamInfo);++ // Prove the FLOCI-LINK-LOCAL rule is strictly required:+ // Temporarily detach FLOCI-LINK-LOCAL from PREROUTING. The pod request now hits CNI-HOSTPORT-DNAT+ // and fails because port 80 is redirected to 9999.+ execInContainer(containerId, new String[]{"sh", "-c",+ "iptables -t nat -D PREROUTING -j FLOCI-LINK-LOCAL"});+ ExecResult intercepted = execInContainerWithExitCode(containerId, new String[]{"sh", "-c",+ "ip netns exec pod-test wget -q -O - -T 2 http://169.254.169.254/latest/meta-data/instance-id"});+ assertNotEquals(0, intercepted.exitCode(),+ "Without FLOCI-LINK-LOCAL chain, pod request should be intercepted by CNI-HOSTPORT-DNAT and fail");++ // Re-insert FLOCI-LINK-LOCAL at rule 1: pod request succeeds again+ execInContainer(containerId, new String[]{"sh", "-c",+ "iptables -t nat -I PREROUTING 1 -j FLOCI-LINK-LOCAL"});+ String restoredInstanceId = execInContainer(containerId, new String[]{"sh", "-c", podInstanceIdCmd});+ assertEquals(instanceId.trim(), restoredInstanceId.trim(),+ "Restoring FLOCI-LINK-LOCAL rule must restore pod reachability");+ } finally {+ execInContainerWithExitCode(containerId, new String[]{"sh", "-c", """+ ip netns del pod-test 2>/dev/null || true+ ip link del cni0 2>/dev/null || true+ iptables -t nat -D PREROUTING -j FLOCI-LINK-LOCAL 2>/dev/null || true+ iptables -t nat -D PREROUTING -m addrtype --dst-type LOCAL -j CNI-HOSTPORT-DNAT 2>/dev/null || true+ iptables -t nat -F CNI-HOSTPORT-DNAT 2>/dev/null || true+ iptables -t nat -X CNI-HOSTPORT-DNAT 2>/dev/null || true+ """});+ }}private boolean isDockerAvailable() {diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRoutingTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRoutingTest.javanew file mode 100644index 0000000000..40d3f9852a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksPodNetworkRoutingTest.java@@ -0,0 +1,94 @@+package io.github.hectorvent.floci.services.eks;++import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class EksPodNetworkRoutingTest {++ @Test+ void linkLocalEndpointValidatesInput() {+ assertThrows(NullPointerException.class, () -> new LinkLocalEndpoint(null, 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint(" ", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("invalid-ip", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169.256", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("-1.0.0.0", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169.254.1", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.01.1", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("; rm -rf / ;", 80));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169.254", 0));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169.254", -1));+ assertThrows(IllegalArgumentException.class, () -> new LinkLocalEndpoint("169.254.169.254", 65536));++ LinkLocalEndpoint ep = new LinkLocalEndpoint("169.254.169.254", 80);+ assertEquals("169.254.169.254", ep.ip());+ assertEquals(80, ep.port());+ }++ @Test+ void buildRoutingCommandRejectsNullOrEmptyEndpoints() {+ assertThrows(IllegalArgumentException.class, () ->+ EksPodNetworkRouting.buildRoutingCommand(null, null));+ assertThrows(IllegalArgumentException.class, () ->+ EksPodNetworkRouting.buildRoutingCommand("10.42.0.0/16", List.of()));+ }++ @Test+ void buildRoutingCommandUsesDefaultPodCidrWhenNullOrBlank() {+ String[] cmdNull = EksPodNetworkRouting.buildRoutingCommand(null, EksPodNetworkRouting.DEFAULT_ENDPOINTS);+ assertEquals(3, cmdNull.length);+ assertEquals("sh", cmdNull[0]);+ assertEquals("-c", cmdNull[1]);+ assertTrue(cmdNull[2].contains(EksPodNetworkRouting.DEFAULT_POD_CIDR));++ String[] cmdBlank = EksPodNetworkRouting.buildRoutingCommand(" ", EksPodNetworkRouting.DEFAULT_ENDPOINTS);+ assertTrue(cmdBlank[2].contains(EksPodNetworkRouting.DEFAULT_POD_CIDR));+ }++ @Test+ void buildRoutingCommandGeneratesIdempotentChainAndRules() {+ String[] cmd = EksPodNetworkRouting.buildRoutingCommand("10.42.0.0/16", List.of(+ new LinkLocalEndpoint("169.254.169.254", 80),+ new LinkLocalEndpoint("169.254.170.23", 80)+ ));++ String script = cmd[2];+ assertNotNull(script);++ // Finds iptables binary across standard and k3s aux locations+ assertTrue(script.contains("IPTABLES=$(command -v iptables 2>/dev/null || command -v /bin/aux/iptables 2>/dev/null || true)"));+ assertTrue(script.contains("iptables not found in container"));++ // Creates custom chain idempotently+ assertTrue(script.contains("$IPTABLES -t nat -N FLOCI-LINK-LOCAL 2>/dev/null || true"));++ // Inserts jump in PREROUTING only if not already present+ assertTrue(script.contains("$IPTABLES -t nat -C PREROUTING -j FLOCI-LINK-LOCAL 2>/dev/null || $IPTABLES -t nat -I PREROUTING 1 -j FLOCI-LINK-LOCAL"));++ // Adds rule for IMDS endpoint with check before append+ String imdsCheck = "$IPTABLES -t nat -C FLOCI-LINK-LOCAL -s 10.42.0.0/16 -d 169.254.169.254 -p tcp --dport 80 -j DNAT --to-destination 169.254.169.254:80 2>/dev/null";+ String imdsAdd = "$IPTABLES -t nat -A FLOCI-LINK-LOCAL -s 10.42.0.0/16 -d 169.254.169.254 -p tcp --dport 80 -j DNAT --to-destination 169.254.169.254:80";+ assertTrue(script.contains(imdsCheck + " || " + imdsAdd));++ // Adds rule for Pod Identity endpoint with check before append+ String podIdCheck = "$IPTABLES -t nat -C FLOCI-LINK-LOCAL -s 10.42.0.0/16 -d 169.254.170.23 -p tcp --dport 80 -j DNAT --to-destination 169.254.170.23:80 2>/dev/null";+ String podIdAdd = "$IPTABLES -t nat -A FLOCI-LINK-LOCAL -s 10.42.0.0/16 -d 169.254.170.23 -p tcp --dport 80 -j DNAT --to-destination 169.254.170.23:80";+ assertTrue(script.contains(podIdCheck + " || " + podIdAdd));+ }++ @Test+ void buildRoutingCommandSupportsCustomCidr() {+ String customCidr = "192.168.0.0/16";+ String[] cmd = EksPodNetworkRouting.buildRoutingCommand(customCidr, EksPodNetworkRouting.DEFAULT_ENDPOINTS);+ String script = cmd[2];++ assertTrue(script.contains("-s 192.168.0.0/16 -d 169.254.169.254"));+ }+}