Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eks): authenticate EC2 workers through access entries (#3805)
luiseterc6b389c33ebdd
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex 5429b9aade..4d42f65bf8 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -37,8 +37,22 @@ The four access-entry management operations support `STANDARD` (the default) andAccess entries use EKS storage and retain the IAM principal's stable ID internally. Cluster deletion removes its entries, and a cluster recreated with the same name does not inherit previous entries or pagination tokens.-!!! note "Management API scope"- These operations currently manage metadata only. They do not change the k3s token webhook's authorization behavior, create cluster-creator or managed-node entries automatically, or make native workers register. Authentication mode and the bootstrap flag are recorded; they are not yet enforced by the Kubernetes API server. Updating authentication mode, UpdateAccessEntry, access-policy association, and entry tag updates are not implemented. Worker authentication is a separate follow-up.+### EC2 Linux worker authentication++IMDS instance-profile credentials authenticate through a matching `EC2_LINUX` entry as+`system:node:<private-DNS-name>` with `system:bootstrappers` and `system:nodes` groups.+The webhook verifies the signed token, cluster account/region/incarnation, stored role ID,+running EC2 instance, and attached instance profile. Missing/deleted entries, recreated roles,+revoked sessions and terminated instances are rejected without falling back to administrator access.+The existing k3s webhook cache can retain a successful authentication for up to 30 seconds.++New cluster webhook configurations carry the target account, region and creation timestamp.+Recreate older local clusters before using worker authentication; a legacy unscoped webhook+rejects instance credentials. Obtain fresh IMDS credentials after upgrading so the session+includes the stable role ID.++!!! note "Authentication scope"+ Non-worker IAM users and ordinary STS sessions retain the existing cluster-admin compatibility behavior. STANDARD entries, access policies, aws-auth ConfigMap, the cluster-creator bootstrap flag and automatic managed-node entries are not enforced by this change. Updating authentication mode, UpdateAccessEntry, access-policy association, and entry tag updates remain unimplemented. Native AL2023 images, bootstrap RBAC/CSR approval, CNI and worker networking are separate requirements for registration and Ready.```bashaws --endpoint-url http://localhost:4566 eks create-cluster \@@ -72,7 +86,7 @@ aws eks update-kubeconfig --name my-clusterkubectl get nodes```-`aws eks update-kubeconfig` wires `aws eks get-token` into the kubeconfig as an exec credential. The bearer token contains a SigV4-presigned STS `GetCallerIdentity` request. Floci validates its signature and 60-second presign expiry, then verifies the signed `x-k8s-aws-id` header against the cluster-specific `/_floci/eks/clusters/<cluster-name>/token-webhook` endpoint before mapping the caller to the `system:masters` group (bound to `cluster-admin`). No `aws-iam-authenticator` is required.+`aws eks update-kubeconfig` wires `aws eks get-token` into the kubeconfig as an exec credential. The bearer token contains a SigV4-presigned STS `GetCallerIdentity` request. Floci validates its signature and 60-second presign expiry, then verifies the signed `x-k8s-aws-id` header against the cluster-specific `/_floci/eks/clusters/<cluster-name>/token-webhook` endpoint before resolving the caller identity. Instance-profile sessions require an EC2_LINUX access entry as described above; non-worker callers retain the `system:masters` mapping (bound to `cluster-admin`). No `aws-iam-authenticator` is required.Create an IAM access key before using EKS authentication. The public local-development pairs `test`/`test` and `floci`/`floci` are deliberately rejected because the webhook grants cluster-admin access.diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentials.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentials.javaindex 18fa63993a..8f44ca8061 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentials.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentials.java@@ -95,6 +95,7 @@ final class Ec2InstanceCredentials {SessionCredential session = new SessionCredential(accessKey, randomString(30), randomString(48),role.getArn(), now.plusSeconds(3600), null, account);session.setEc2InstanceId(instance.getInstanceId());+ session.setEc2RoleId(role.getRoleId());iam.registerEc2InstanceSession(session);history.add(new Issued(session, role.getRoleId(), instance.getIamInstanceProfileArn()));return Optional.of(session);diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 74b670f6a8..d7ab8f0ed6 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -4632,6 +4632,11 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {return kp;}+ public Optional<Instance> findInstanceForAccount(String accountId, String region, String instanceId) {+ return instances instanceof AccountAwareStorageBackend<Instance> aware+ ? aware.getForAccount(accountId, key(region, instanceId)) : instances.get(key(region, instanceId));+ }+public Instance findInstanceById(String instanceId) {return instances.scan(k -> true).stream().filter(i -> instanceId.equals(i.getInstanceId()))diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksAccessEntryService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksAccessEntryService.javaindex 103628a4ba..642e88f982 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksAccessEntryService.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksAccessEntryService.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.eks;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.eks.model.AccessEntry;@@ -22,6 +23,7 @@ import java.util.Comparator;import java.util.List;import java.util.Map;import java.util.Objects;+import java.util.Optional;import java.util.UUID;/** Access-entry management metadata; Kubernetes authorization is handled separately. */@@ -132,6 +134,15 @@ public class EksAccessEntryService {return entry;}+ synchronized Optional<AccessEntry> workerEntry(Cluster cluster, String accountId, String principal, String roleId) {+ requireApiAccess(cluster);+ String key = prefix(cluster) + principal;+ Optional<StoredEntry> stored = entries instanceof AccountAwareStorageBackend<StoredEntry> aware+ ? aware.getForAccount(accountId, key) : entries.get(key);+ return stored.filter(value -> roleId != null && roleId.equals(value.principalId()))+ .map(StoredEntry::entry).filter(entry -> "EC2_LINUX".equals(entry.type()));+ }+public synchronized AccessEntry describe(Cluster cluster, String principal) {requireApiAccess(cluster);return entries.get(prefix(cluster) + principal).map(StoredEntry::entry)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 c2b5d3b7dc..153a3a5d9f 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@@ -210,14 +210,14 @@ public class EksClusterManager {}// Wire a token-authentication webhook so `aws eks get-token` bearer tokens are validated by- // Floci and mapped to cluster-admin. The k3s API server POSTs a TokenReview to Floci's+ // Floci and mapped to their Kubernetes identity. The k3s API server POSTs a TokenReview to Floci's// _floci/eks/clusters/<cluster-name>/token-webhook endpoint. The kubeconfig is copied into// the container via the Docker API after create and before start (below), not bind-mounted,// so it works the same natively and in Docker-in-Docker, with no host-path /// host-persistent-path requirement.String webhookLocalFile = null;if (config.services().eks().iamAuthWebhook()) {- webhookLocalFile = writeWebhookKubeconfig(cluster.getName());+ webhookLocalFile = writeWebhookKubeconfig(cluster);if (webhookLocalFile != null) {specBuilder.withHostDockerInternalOnLinux();serverArgs.add("--kube-apiserver-arg=authentication-token-webhook-config-file="@@ -567,12 +567,14 @@ public class EksClusterManager {* written (in which case the caller skips the webhook so cluster creation still succeeds). The* file is later streamed into the container via the Docker API, so no host path is involved.*/- private String writeWebhookKubeconfig(String clusterName) {+ private String writeWebhookKubeconfig(Cluster cluster) {+ String clusterName = cluster.getName();Path localFile = Paths.get(config.services().eks().dataPath(), "webhook", clusterName, WEBHOOK_CONFIG_FILE).toAbsolutePath().normalize();try {Files.createDirectories(localFile.getParent());- Files.writeString(localFile, buildWebhookKubeconfig(webhookUrl(clusterName)));+ Files.writeString(localFile, buildWebhookKubeconfig("http://" + dockerHostResolver.resolve() + ":"+ + config.port() + webhookPath(cluster)));} catch (IOException e) {LOG.warnv("EKS token-webhook disabled for cluster {0}: could not write kubeconfig: {1}",clusterName, e.getMessage());@@ -697,6 +699,11 @@ public class EksClusterManager {return "http://" + dockerHostResolver.resolve() + ":" + config.port() + webhookPath(clusterName);}+ static String webhookPath(Cluster cluster) {+ return webhookPath(cluster.getName()) + "?accountId=" + cluster.getAccountId()+ + "®ion=" + cluster.getArn().split(":", 6)[3] + "&createdAt=" + cluster.getCreatedAt();+ }+static String webhookPath(String clusterName) {return "/_floci/eks/clusters/" + clusterName + "/token-webhook";}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.javaindex dc847b066b..d6c99b0492 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java@@ -38,6 +38,7 @@ import java.util.HashMap;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+import java.util.Optional;import java.util.UUID;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;@@ -302,6 +303,11 @@ public class EksService implements TagHandler, ResourceProvider {cluster.setEndpoint("https://localhost:" + config.services().eks().apiServerBasePort());}+ public Optional<Cluster> findAuthenticationCluster(String accountId, String name) {+ return storage instanceof AccountAwareStorageBackend<Cluster> aware+ ? aware.getForAccount(accountId, name) : storage.get(name);+ }+public Cluster describeCluster(String name) {return storage.get(name).orElseThrow(() -> new AwsException("ResourceNotFoundException",diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenValidator.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenValidator.javaindex e8df4806d4..3bc2f47fc5 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenValidator.java@@ -54,32 +54,38 @@ class EksTokenValidator {this.clock = clock;}+ record VerifiedToken(String accessKeyId, String region) {}+boolean validate(String token, String clusterName) {+ return verify(token, clusterName).isPresent();+ }++ Optional<VerifiedToken> verify(String token, String clusterName) {if (token == null || clusterName == null || clusterName.isBlank() || token.length() > MAX_TOKEN_LENGTH) {- return false;+ return Optional.empty();}try {URI request = parseToken(token);if (request == null) {- return false;+ return Optional.empty();}Map<String, String> parameters = parseQuery(request.getRawQuery());if (!hasExpectedRequestShape(request, parameters)) {- return false;+ return Optional.empty();}CredentialScope scope = parseCredentialScope(parameters.get("X-Amz-Credential"));Instant signedAt = Instant.from(DATETIME_FORMAT.parse(parameters.get("X-Amz-Date")));if (!isCurrent(signedAt, parameters.get("X-Amz-Expires"))|| !scope.date().equals(parameters.get("X-Amz-Date").substring(0, 8))) {- return false;+ return Optional.empty();}String secretKey = secretKey(scope.accessKeyId(), parameters.get("X-Amz-Security-Token"));if (secretKey == null) {- return false;+ return Optional.empty();}String canonicalRequest = canonicalRequest(request, parameters, clusterName);@@ -89,12 +95,13 @@ class EksTokenValidator {+ sha256Hex(canonicalRequest);String expectedSignature = hexEncode(hmacSha256(deriveSigningKey(secretKey, scope.date(), scope.region(), scope.service()), stringToSign));- return MessageDigest.isEqual(+ boolean valid = MessageDigest.isEqual(expectedSignature.getBytes(StandardCharsets.UTF_8),parameters.get("X-Amz-Signature").getBytes(StandardCharsets.UTF_8));+ return valid ? Optional.of(new VerifiedToken(scope.accessKeyId(), scope.region())) : Optional.empty();} catch (Exception exception) {LOG.debugv("EKS IAM token validation rejected a malformed token: {0}", exception.getMessage());- return false;+ return Optional.empty();}}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookController.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookController.javaindex 13c1d9d2ee..2d6ead6026 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookController.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookController.java@@ -7,12 +7,13 @@ import jakarta.ws.rs.POST;import jakarta.ws.rs.Path;import jakarta.ws.rs.PathParam;import jakarta.ws.rs.Produces;+import jakarta.ws.rs.QueryParam;import jakarta.ws.rs.core.MediaType;import jakarta.ws.rs.core.Response;import org.jboss.logging.Logger;-import java.util.List;import java.util.Map;+import java.util.Optional;/*** Kubernetes token-authentication webhook for k3s-backed EKS clusters.@@ -20,8 +21,8 @@ import java.util.Map;* <p>The k3s API server is configured (see {@code EksClusterManager}) to POST a* {@code TokenReview} here whenever it receives a bearer token it does not recognise, notably the* {@code k8s-aws-v1.<presigned-sts-url>} token produced by {@code aws eks get-token}. Floci validates- * the request signature, expiration, and signed cluster ID before mapping the token to the- * {@code system:masters} group, which is bound to {@code cluster-admin} by default.+ * the request signature, expiration, and signed cluster ID before resolving worker access entries.+ * Non-worker credentials retain the legacy cluster-admin compatibility behavior.** <p>This is Floci plumbing under the {@code _floci/...} namespace, not an AWS API.*/@@ -33,34 +34,36 @@ public class EksTokenWebhookController {private static final Logger LOG = Logger.getLogger(EksTokenWebhookController.class);private final EksTokenValidator tokenValidator;+ private final EksWorkerAuthentication authentication;@Inject- public EksTokenWebhookController(EksTokenValidator tokenValidator) {+ public EksTokenWebhookController(EksTokenValidator tokenValidator, EksWorkerAuthentication authentication) {this.tokenValidator = tokenValidator;+ this.authentication = authentication;}@POST- public Response review(@PathParam("clusterName") String clusterName, Map<String, Object> tokenReview) {+ public Response review(@PathParam("clusterName") String clusterName, @QueryParam("accountId") String accountId,+ @QueryParam("region") String region, @QueryParam("createdAt") String createdAt,+ Map<String, Object> tokenReview) {// The response apiVersion MUST match the request's (the kube-apiserver sends v1beta1 by// default and cannot convert a v1 response back). Echo whatever the apiserver sent.String apiVersion = tokenReview != null && tokenReview.get("apiVersion") instanceof String v? v : "authentication.k8s.io/v1";String token = extractToken(tokenReview);- boolean authenticated = tokenValidator.validate(token, clusterName);+ Optional<Map<String, Object>> user = tokenValidator.verify(token, clusterName)+ .flatMap(verified -> authentication.authenticate(verified, clusterName, accountId, region, createdAt));- if (authenticated) {- LOG.debugv("EKS token-webhook: authenticated aws-iam token for cluster {0} as cluster-admin",+ if (user.isPresent()) {+ LOG.debugv("EKS token-webhook: authenticated aws-iam token for cluster {0}",clusterName);return Response.ok(Map.of("apiVersion", apiVersion,"kind", "TokenReview","status", Map.of("authenticated", true,- "user", Map.of(- "username", "floci:aws-iam",- "uid", "floci-aws-iam",- "groups", List.of("system:masters"))))).build();+ "user", user.get()))).build();}LOG.debugv("EKS token-webhook: rejected aws-iam token for cluster {0}", clusterName);diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthentication.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthentication.javanew file mode 100644index 0000000000..b0f3d20a49--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthentication.java@@ -0,0 +1,96 @@+package io.github.hectorvent.floci.services.eks;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.IamService.EksSessionIdentity;+import io.github.hectorvent.floci.services.iam.model.IamRole;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.util.List;+import java.util.Map;+import java.util.Optional;++/** Maps verified instance credentials to node identities using server-owned EC2 metadata. */+@ApplicationScoped+class EksWorkerAuthentication {+ private final IamService iam;+ private final EksService eks;+ private final Ec2Service ec2;+ private final EksAccessEntryService entries;++ @Inject+ EksWorkerAuthentication(IamService iam, EksService eks, Ec2Service ec2, EksAccessEntryService entries) {+ this.iam = iam;+ this.eks = eks;+ this.ec2 = ec2;+ this.entries = entries;+ }++ Optional<Map<String, Object>> authenticate(EksTokenValidator.VerifiedToken token, String name,+ String account, String region, String createdAt) {+ Optional<EksSessionIdentity> session = iam.findEksSessionIdentity(token.accessKeyId());+ // Keep the existing non-worker compatibility path. Expired/revoked temporary sessions+ // must never fall through to it after signature validation.+ if (session.isEmpty()) {+ return IamService.isTemporaryAccessKey(token.accessKeyId()) ? Optional.empty() : legacyIdentity();+ }+ EksSessionIdentity identity = session.get();+ if (identity.instanceId() == null) {+ return legacyIdentity();+ }+ if (account == null || region == null || createdAt == null || !account.equals(identity.accountId())+ || !region.equals(token.region()) || identity.roleArn() == null || identity.roleId() == null) {+ return Optional.empty();+ }+ Optional<Cluster> cluster = eks.findAuthenticationCluster(account, name)+ .filter(value -> value.getArn() != null && value.getArn().equals(+ "arn:aws:eks:" + region + ":" + account + ":cluster/" + name))+ .filter(value -> createdAt.equals(String.valueOf(value.getCreatedAt())));+ if (cluster.isEmpty()) {+ return Optional.empty();+ }+ String roleName = identity.roleArn().substring(identity.roleArn().lastIndexOf('/') + 1);+ Optional<IamRole> role = iam.findRole(account, roleName)+ .filter(value -> identity.roleArn().equals(value.getArn()) && identity.roleId().equals(value.getRoleId()));+ if (role.isEmpty()) {+ return Optional.empty();+ }+ try {+ if (entries.workerEntry(cluster.get(), account, identity.roleArn(), identity.roleId()).isEmpty()) {+ return Optional.empty();+ }+ } catch (AwsException rejected) {+ return Optional.empty();+ }+ Optional<Instance> instance = ec2.findInstanceForAccount(account, region, identity.instanceId())+ .filter(value -> value.getState() != null && "running".equals(value.getState().getName()))+ .filter(value -> region.equals(value.getRegion()))+ .filter(value -> profileMatches(value, account, roleName));+ if (instance.isEmpty() || instance.get().getPrivateDnsName() == null+ || instance.get().getPrivateDnsName().isBlank()) {+ return Optional.empty();+ }+ return Optional.of(Map.of("username", "system:node:" + instance.get().getPrivateDnsName(),+ "uid", account + ":" + identity.roleId() + ":" + identity.instanceId(),+ "groups", List.of("system:bootstrappers", "system:nodes")));+ }++ private boolean profileMatches(Instance instance, String account, String roleName) {+ String arn = instance.getIamInstanceProfileArn();+ if (arn == null || !arn.startsWith("arn:aws:iam::" + account + ":instance-profile/")) {+ return false;+ }+ return iam.findInstanceProfile(account, arn.substring(arn.lastIndexOf('/') + 1))+ .filter(profile -> arn.equals(profile.getArn()))+ .filter(profile -> List.of(roleName).equals(profile.getRoleNames())).isPresent();+ }++ private static Optional<Map<String, Object>> legacyIdentity() {+ return Optional.of(Map.of("username", "floci:aws-iam", "uid", "floci-aws-iam",+ "groups", List.of("system:masters")));+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex b3ee30084d..3bff7656f8 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java@@ -1883,6 +1883,14 @@ public class IamService implements SessionAccountLookup, ResourceProvider {.map(AccessKey::getSecretAccessKey);}+ public record EksSessionIdentity(String accountId, String roleArn, String roleId, String instanceId) {}++ /** Returns only identity metadata, never the session secret or token. */+ public Optional<EksSessionIdentity> findEksSessionIdentity(String accessKeyId) {+ return currentSession(accessKeyId).map(session -> new EksSessionIdentity(+ session.getOriginAccountId(), session.getRoleArn(), session.getEc2RoleId(), session.getEc2InstanceId()));+ }+private Optional<SessionCredential> currentSession(String accessKeyId) {return findSessionAnyAccount(accessKeyId).filter(session -> session.getExpiration() == null || Instant.now().isBefore(session.getExpiration()));diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/SessionCredential.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/SessionCredential.javaindex 9b33b4563c..412119ea60 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/model/SessionCredential.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/SessionCredential.java@@ -24,6 +24,7 @@ public class SessionCredential {/** True when this session belongs to a Floci-launched Lambda container. */private boolean lambdaExecutionRole;private String ec2InstanceId;+ private String ec2RoleId;public SessionCredential() {}@@ -92,6 +93,9 @@ public class SessionCredential {public String getOriginAccountId() { return originAccountId; }public void setOriginAccountId(String originAccountId) { this.originAccountId = originAccountId; }+ public String getEc2RoleId() { return ec2RoleId; }+ public void setEc2RoleId(String ec2RoleId) { this.ec2RoleId = ec2RoleId; }+public String getEc2InstanceId() { return ec2InstanceId; }public void setEc2InstanceId(String ec2InstanceId) { this.ec2InstanceId = ec2InstanceId; }diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentialsTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentialsTest.javaindex 4b79863785..107c0f9ff0 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentialsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceCredentialsTest.java@@ -32,6 +32,7 @@ class Ec2InstanceCredentialsTest {assertEquals(40, first.getSecretAccessKey().length());assertEquals(ACCOUNT, first.getOriginAccountId());assertEquals("i-first", first.getEc2InstanceId());+ assertEquals(fixture.role.getRoleId(), first.getEc2RoleId());assertEquals(NOW.plusSeconds(3600), first.getExpiration());verify(fixture.iam).registerEc2InstanceSession(first);assertSame(first, fixture.get(NOW.plusSeconds(3299)));diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/EksWorkerAuthenticationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/EksWorkerAuthenticationIntegrationTest.javanew file mode 100644index 0000000000..f74410ef65--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/EksWorkerAuthenticationIntegrationTest.java@@ -0,0 +1,99 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceState;+import io.github.hectorvent.floci.services.eks.EksService;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.SessionCredential;+import io.github.hectorvent.floci.testutil.SigV4TokenTestHelper;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++@QuarkusTest+class EksWorkerAuthenticationIntegrationTest {+ @Inject IamService iam;+ @Inject Ec2Service ec2;+ @Inject EksService eks;++ @Test+ void instanceCredentialsAuthenticateOnlyWithMatchingLiveAccessEntry() throws Exception {+ String account = "246813579012";+ String name = "worker-auth-" + UUID.randomUUID().toString().substring(0, 8);+ String roleArn = "arn:aws:iam::" + account + ":role/path/" + name;+ String profileArn = "arn:aws:iam::" + account + ":instance-profile/" + name;+ given().header("Authorization", auth(account, "iam"))+ .formParam("Action", "CreateRole").formParam("RoleName", name).formParam("Path", "/path/")+ .formParam("AssumeRolePolicyDocument", "{}").post("/").then().statusCode(200);+ given().header("Authorization", auth(account, "iam"))+ .formParam("Action", "CreateInstanceProfile").formParam("InstanceProfileName", name)+ .post("/").then().statusCode(200);+ given().header("Authorization", auth(account, "iam"))+ .formParam("Action", "AddRoleToInstanceProfile").formParam("InstanceProfileName", name)+ .formParam("RoleName", name).post("/").then().statusCode(200);+ String instanceId = given().header("Authorization", auth(account, "ec2"))+ .formParam("Action", "RunInstances").formParam("ImageId", "ami-0abcdef1234567890")+ .formParam("InstanceType", "t3.micro").formParam("MinCount", "1").formParam("MaxCount", "1")+ .formParam("IamInstanceProfile.Arn", profileArn).post("/").then().statusCode(200)+ .extract().path("RunInstancesResponse.instancesSet.item.instanceId");+ given().header("Authorization", auth(account, "eks")).contentType("application/json")+ .body(Map.of("name", name, "roleArn", roleArn, "accessConfig",+ Map.of("authenticationMode", "API", "bootstrapClusterCreatorAdminPermissions", false)))+ .post("/clusters").then().statusCode(200);+ Ec2InstanceCredentials credentials = new Ec2InstanceCredentials(iam);+ try {+ Instance instance = ec2.findInstanceForAccount(account, "us-east-1", instanceId).orElseThrow();+ // Mock EC2 launches remain pending because no container manager runs in this profile.+ instance.setState(InstanceState.running());+ credentials.register(instance);+ SessionCredential session = credentials.get(instance, name, Instant.now()).orElseThrow();+ String token = SigV4TokenTestHelper.createEksToken(name, session.getAccessKeyId(),+ session.getSecretAccessKey(), Instant.now(), 60, session.getSessionToken());+ String incarnation = eks.findAuthenticationCluster(account, name).orElseThrow().getCreatedAt().toString();+ String path = "/_floci/eks/clusters/" + name + "/token-webhook";+ Map<String, Object> review = Map.of("apiVersion", "authentication.k8s.io/v1", "kind", "TokenReview",+ "spec", Map.of("token", token));+ given().queryParam("accountId", account).queryParam("region", "us-east-1")+ .queryParam("createdAt", incarnation).contentType("application/json").body(review)+ .post(path).then().statusCode(200).body("status.authenticated", equalTo(false));+ given().header("Authorization", auth(account, "eks")).contentType("application/json")+ .body(Map.of("principalArn", roleArn, "type", "EC2_LINUX"))+ .post("/clusters/" + name + "/access-entries").then().statusCode(200);+ given().queryParam("accountId", account).queryParam("region", "us-east-1")+ .queryParam("createdAt", incarnation).contentType("application/json").body(review)+ .post(path).then().statusCode(200).body("status.authenticated", equalTo(true))+ .body("status.user.username", equalTo("system:node:" + instance.getPrivateDnsName()))+ .body("status.user.groups", contains("system:bootstrappers", "system:nodes"));+ given().queryParam("accountId", "999999999999").queryParam("region", "us-east-1")+ .queryParam("createdAt", incarnation).contentType("application/json").body(review)+ .post(path).then().statusCode(200).body("status.authenticated", equalTo(false));+ credentials.unregister(instance);+ given().queryParam("accountId", account).queryParam("region", "us-east-1")+ .queryParam("createdAt", incarnation).contentType("application/json").body(review)+ .post(path).then().statusCode(200).body("status.authenticated", equalTo(false));+ } finally {+ credentials.clear();+ given().header("Authorization", auth(account, "eks")).delete("/clusters/" + name).then().statusCode(200);+ given().header("Authorization", auth(account, "ec2")).formParam("Action", "TerminateInstances")+ .formParam("InstanceId.1", instanceId).post("/").then().statusCode(200);+ given().header("Authorization", auth(account, "iam")).formParam("Action", "RemoveRoleFromInstanceProfile")+ .formParam("InstanceProfileName", name).formParam("RoleName", name).post("/").then().statusCode(200);+ given().header("Authorization", auth(account, "iam")).formParam("Action", "DeleteInstanceProfile")+ .formParam("InstanceProfileName", name).post("/").then().statusCode(200);+ given().header("Authorization", auth(account, "iam")).formParam("Action", "DeleteRole")+ .formParam("RoleName", name).post("/").then().statusCode(200);+ }+ }++ private static String auth(String account, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + account+ + "/20260917/us-east-1/" + service + "/aws4_request, SignedHeaders=host, Signature=abc";+ }+}diff --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 76037be657..34fc86efe0 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@@ -37,6 +37,7 @@ import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;import org.mockito.Mockito;+import java.time.Instant;import java.nio.file.Path;import java.util.ArrayList;import java.util.Arrays;@@ -59,6 +60,17 @@ import static org.mockito.Mockito.when;class EksClusterManagerTest {+ @Test+ void workerWebhookBindsAccountRegionAndClusterIncarnation() {+ Cluster cluster = new Cluster();+ cluster.setName("demo");+ cluster.setAccountId("123456789012");+ cluster.setArn("arn:aws:eks:us-west-2:123456789012:cluster/demo");+ cluster.setCreatedAt(Instant.parse("2026-09-17T00:00:00Z"));+ assertEquals("/_floci/eks/clusters/demo/token-webhook?accountId=123456789012"+ + "®ion=us-west-2&createdAt=2026-09-17T00:00:00Z", EksClusterManager.webhookPath(cluster));+ }+@Testvoid webhookPathBindsAuthenticationToOneCluster() {assertEquals("/_floci/eks/clusters/demo/token-webhook", EksClusterManager.webhookPath("demo"));diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookControllerTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookControllerTest.javaindex f595111718..78726d38b8 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookControllerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksTokenWebhookControllerTest.java@@ -22,7 +22,7 @@ class EksTokenWebhookControllerTest {private final IamService iamService = IamServiceTestHelper.iamServiceWithAccessKey(ACCESS_KEY_ID, SECRET_ACCESS_KEY);private final EksTokenWebhookController controller = new EksTokenWebhookController(- new EksTokenValidator(iamService));+ new EksTokenValidator(iamService), new EksWorkerAuthentication(iamService, null, null, null));@SuppressWarnings("unchecked")private Map<String, Object> status(Response response) {@@ -40,7 +40,7 @@ class EksTokenWebhookControllerTest {@Test@SuppressWarnings("unchecked")void awsIamTokenAuthenticatesAsClusterAdmin() throws Exception {- Response response = controller.review(CLUSTER_NAME, tokenReview(validToken()));+ Response response = controller.review(CLUSTER_NAME, null, null, null, tokenReview(validToken()));Map<String, Object> status = status(response);assertEquals(Boolean.TRUE, status.get("authenticated"));@@ -51,20 +51,20 @@ class EksTokenWebhookControllerTest {@Testvoid unrecognisedTokenIsRejected() {- Response response = controller.review(CLUSTER_NAME, tokenReview("some-random-bearer-token"));+ Response response = controller.review(CLUSTER_NAME, null, null, null, tokenReview("some-random-bearer-token"));assertEquals(Boolean.FALSE, status(response).get("authenticated"));}@Testvoid emptyOrMalformedReviewIsRejected() {- assertFalse((Boolean) status(controller.review(CLUSTER_NAME, Map.of())).get("authenticated"));- assertFalse((Boolean) status(controller.review(CLUSTER_NAME,+ assertFalse((Boolean) status(controller.review(CLUSTER_NAME, null, null, null, Map.of())).get("authenticated"));+ assertFalse((Boolean) status(controller.review(CLUSTER_NAME, null, null, null,Map.of("spec", Map.of()))).get("authenticated"));}@Testvoid responseIsAlwaysAWellFormedTokenReview() throws Exception {- Response response = controller.review(CLUSTER_NAME, tokenReview(validToken()));+ Response response = controller.review(CLUSTER_NAME, null, null, null, tokenReview(validToken()));Map<?, ?> body = (Map<?, ?>) response.getEntity();assertEquals("authentication.k8s.io/v1", body.get("apiVersion"));assertEquals("TokenReview", body.get("kind"));@@ -80,7 +80,7 @@ class EksTokenWebhookControllerTest {"kind", "TokenReview","spec", Map.of("token", validToken()));- Response response = controller.review(CLUSTER_NAME, v1beta1Review);+ Response response = controller.review(CLUSTER_NAME, null, null, null, v1beta1Review);Map<?, ?> body = (Map<?, ?>) response.getEntity();assertEquals("authentication.k8s.io/v1beta1", body.get("apiVersion"));assertEquals(Boolean.TRUE, status(response).get("authenticated"));@@ -91,7 +91,7 @@ class EksTokenWebhookControllerTest {String token = SigV4TokenTestHelper.createEksToken("other-cluster", ACCESS_KEY_ID, SECRET_ACCESS_KEY, Instant.now(), 60);- Response response = controller.review(CLUSTER_NAME, tokenReview(token));+ Response response = controller.review(CLUSTER_NAME, null, null, null, tokenReview(token));assertEquals(Boolean.FALSE, status(response).get("authenticated"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthenticationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthenticationTest.javanew file mode 100644index 0000000000..f1576019cd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksWorkerAuthenticationTest.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.eks;++import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceState;+import io.github.hectorvent.floci.services.eks.model.AccessConfig;+import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.github.hectorvent.floci.services.eks.model.ClusterStatus;+import io.github.hectorvent.floci.services.eks.model.CreateAccessEntryRequest;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.IamService.EksSessionIdentity;+import io.github.hectorvent.floci.services.iam.model.IamRole;+import io.github.hectorvent.floci.services.iam.model.InstanceProfile;+import io.github.hectorvent.floci.testutil.SigV4TokenTestHelper;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.util.List;+import java.util.Map;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.*;++class EksWorkerAuthenticationTest {+ private static final String ACCOUNT = "123456789012";+ private static final String REGION = "us-east-1";+ private static final String ROLE = "arn:aws:iam::" + ACCOUNT + ":role/path/worker";+ private static final String KEY = "ASIAWORKER";+ private static final Instant CREATED = Instant.parse("2026-09-17T00:00:00Z");+ private final IamService iam = mock(IamService.class);+ private final EksService eks = mock(EksService.class);+ private final Ec2Service ec2 = mock(Ec2Service.class);+ private final EksAccessEntryService entries = new EksAccessEntryService(new InMemoryStorage<>(), iam);+ private final Cluster cluster = new Cluster();+ private final Instance instance = new Instance();+ private final IamRole role = new IamRole("AROA-original", "worker", "/path/", ROLE, "{}");+ private final EksWorkerAuthentication auth = new EksWorkerAuthentication(iam, eks, ec2, entries);+ private final EksTokenValidator.VerifiedToken verified = new EksTokenValidator.VerifiedToken(KEY, REGION);++ @BeforeEach+ void setup() {+ cluster.setName("demo");+ cluster.setArn("arn:aws:eks:" + REGION + ":" + ACCOUNT + ":cluster/demo");+ cluster.setCreatedAt(CREATED);+ cluster.setStatus(ClusterStatus.ACTIVE);+ cluster.setAccessConfig(new AccessConfig("API", false));+ instance.setInstanceId("i-worker");+ instance.setRegion(REGION);+ instance.setState(InstanceState.running());+ instance.setPrivateDnsName("ip-10-0-0-1.ec2.internal");+ instance.setIamInstanceProfileArn("arn:aws:iam::" + ACCOUNT + ":instance-profile/path/worker-profile");+ InstanceProfile profile = new InstanceProfile("AIPA", "worker-profile", "/path/", instance.getIamInstanceProfileArn());+ profile.setRoleNames(List.of("worker"));+ when(iam.findRole(ACCOUNT, "worker")).thenReturn(Optional.of(role));+ when(iam.findInstanceProfile(ACCOUNT, "worker-profile")).thenReturn(Optional.of(profile));+ when(iam.findEksSessionIdentity(KEY)).thenReturn(Optional.of(+ new EksSessionIdentity(ACCOUNT, ROLE, role.getRoleId(), instance.getInstanceId())));+ when(eks.findAuthenticationCluster(ACCOUNT, "demo")).thenReturn(Optional.of(cluster));+ when(ec2.findInstanceForAccount(ACCOUNT, REGION, "i-worker")).thenReturn(Optional.of(instance));+ createEntry("EC2_LINUX");+ }++ @Test+ void signedWorkerTokenProducesNodeIdentityWithoutAdministratorGroup() throws Exception {+ when(iam.findSecretKey(KEY, "session-token")).thenReturn(Optional.of("worker-secret"));+ String token = SigV4TokenTestHelper.createEksToken("demo", KEY, "worker-secret", Instant.now(), 60, "session-token");+ EksTokenWebhookController controller = new EksTokenWebhookController(new EksTokenValidator(iam), auth);+ Map<?, ?> response = (Map<?, ?>) controller.review("demo", ACCOUNT, REGION, CREATED.toString(),+ Map.of("spec", Map.of("token", token))).getEntity();+ Map<?, ?> status = (Map<?, ?>) response.get("status");+ assertEquals(true, status.get("authenticated"));+ Map<?, ?> user = (Map<?, ?>) status.get("user");+ assertEquals("system:node:ip-10-0-0-1.ec2.internal", user.get("username"));+ assertEquals(List.of("system:bootstrappers", "system:nodes"), user.get("groups"));+ when(iam.findSecretKey(KEY, "session-token")).thenReturn(Optional.empty());+ response = (Map<?, ?>) controller.review("demo", ACCOUNT, REGION, CREATED.toString(),+ Map.of("spec", Map.of("token", token))).getEntity();+ assertEquals(Map.of("authenticated", false), response.get("status"));+ }++ @Test+ void missingOrStandardEntryDoesNotFallBackToAdministrator() {+ entries.delete(cluster, ROLE);+ assertTrue(authenticate().isEmpty());+ createEntry("STANDARD");+ assertTrue(authenticate().isEmpty());+ }++ @Test+ void changedRoleIdInvalidatesEntryAndOldInstanceCredentials() {+ role.setRoleId("AROA-recreated");+ assertTrue(authenticate().isEmpty());+ when(iam.findEksSessionIdentity(KEY)).thenReturn(Optional.of(+ new EksSessionIdentity(ACCOUNT, ROLE, role.getRoleId(), "i-worker")));+ assertTrue(authenticate().isEmpty());+ entries.delete(cluster, ROLE);+ createEntry("EC2_LINUX");+ assertTrue(authenticate().isPresent());+ }++ @Test+ void missingStoppedOrUnprofiledInstanceIsRejected() {+ instance.setState(InstanceState.terminated());+ assertTrue(authenticate().isEmpty());+ instance.setState(InstanceState.running());+ instance.setIamInstanceProfileArn(null);+ assertTrue(authenticate().isEmpty());+ when(ec2.findInstanceForAccount(ACCOUNT, REGION, "i-worker")).thenReturn(Optional.empty());+ assertTrue(authenticate().isEmpty());+ }++ @Test+ void wrongTargetOrClusterIncarnationIsRejected() {+ assertTrue(auth.authenticate(verified, "demo", "999999999999", REGION, CREATED.toString()).isEmpty());+ assertTrue(auth.authenticate(verified, "demo", ACCOUNT, "us-west-2", CREATED.toString()).isEmpty());+ assertTrue(auth.authenticate(verified, "other", ACCOUNT, REGION, CREATED.toString()).isEmpty());+ assertTrue(auth.authenticate(verified, "demo", null, null, null).isEmpty());+ cluster.setCreatedAt(CREATED.plusSeconds(1));+ assertTrue(authenticate().isEmpty());+ assertTrue(auth.authenticate(verified, "demo", ACCOUNT, REGION, cluster.getCreatedAt().toString()).isEmpty());+ }++ @Test+ void configMapAndInactiveClustersRejectWorkers() {+ cluster.setStatus(ClusterStatus.CREATING);+ assertTrue(authenticate().isEmpty());+ cluster.setStatus(ClusterStatus.ACTIVE);+ cluster.setAccessConfig(new AccessConfig("CONFIG_MAP", false));+ assertTrue(authenticate().isEmpty());+ }++ @Test+ void revokedSessionDoesNotFallBackToAdministrator() {+ when(iam.findEksSessionIdentity(KEY)).thenReturn(Optional.empty());+ assertTrue(authenticate().isEmpty());+ }++ @Test+ void missingRoleIdOrPrivateDnsIsRejected() {+ instance.setPrivateDnsName("");+ assertTrue(authenticate().isEmpty());+ when(iam.findEksSessionIdentity(KEY)).thenReturn(Optional.of(new EksSessionIdentity(ACCOUNT, ROLE, null, "i-worker")));+ assertTrue(authenticate().isEmpty());+ }++ private Optional<Map<String, Object>> authenticate() {+ return auth.authenticate(verified, "demo", ACCOUNT, REGION, CREATED.toString());+ }++ private void createEntry(String type) {+ entries.create(cluster, new CreateAccessEntryRequest(ROLE, type, null, null, null, null));+ }+}