Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambda): mint EKS bearer tokens natively for the kubernetes executor (#2981)
Priamo Germosen252bfe85a2d5
diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex 3c546c512a..a5a1cd3302 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -322,10 +322,12 @@ environment as a Kubernetes pod instead of a Docker container. This is designedfor CI/CD clusters where privileged containers and `docker.sock` access are notallowed. Floci talks to the cluster through the standard Kubernetes API: whenrunning inside the cluster it uses its ServiceAccount, and when running outside-it uses your local kubeconfig. Only an inline static bearer `token` or a-client-certificate/client-key credential with a PKCS#8 private key is-supported; `tokenFile`, exec, and auth-provider credential plugins-(`aws eks get-token`, gcloud, etc.) are not, and fail with a named error.+it uses your local kubeconfig. An inline static bearer `token`, a+client-certificate/client-key credential with a PKCS#8 private key, or the+`aws eks get-token --cluster-name <name> [--region <region>]` exec plugin+(what `aws eks update-kubeconfig` generates) is supported. `--role-arn`,+`tokenFile`, any other exec command, and auth-provider credential plugins+(gcloud, etc.) are not, and fail with a named error.How an invocation works:diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.javanew file mode 100644index 0000000000..9354f46758--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.java@@ -0,0 +1,507 @@+package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;++import com.fasterxml.jackson.databind.JsonNode;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;+import java.security.GeneralSecurityException;+import java.security.MessageDigest;+import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.Base64;+import java.util.LinkedHashMap;+import java.util.Map;+import java.util.Optional;+import java.util.TreeMap;+import java.util.function.Supplier;+import java.util.function.UnaryOperator;+import java.util.stream.Collectors;++/**+ * Mints EKS bearer tokens the way {@code aws eks get-token} does: a presigned+ * {@code sts:GetCallerIdentity} URL with an {@code x-k8s-aws-id} header bound into the+ * signature, base64url-encoded and prefixed with {@code k8s-aws-v1.}. This is the format+ * the {@code aws-iam-authenticator} webhook that fronts EKS clusters expects; see+ * https://github.com/kubernetes-sigs/aws-iam-authenticator's token generator for the reference+ * implementation this mirrors: a 60-second {@code X-Amz-Expires} (STS ignores it for this+ * action; real validity is a verifier-enforced 15 minutes off {@code X-Amz-Date}), refreshed+ * a minute early for clock-skew slack.+ *+ * <p>Lets the kubernetes Lambda executor reach a real EKS cluster without shelling out to+ * the AWS CLI or an exec-credential plugin process, keeping {@link KubernetesApiClient}+ * dependency-free (see its class javadoc for why that matters).+ *+ * <p>Only {@code eks get-token --cluster-name <name>} is recognized, as {@code aws eks+ * update-kubeconfig} actually generates it: {@code get-token} need not be the first two+ * arguments (a global {@code --region} always precedes it in a generated kubeconfig, and+ * {@code --output json} follows), so recognition scans for that pair anywhere in the args+ * list rather than requiring it at a fixed position. {@code --role}/{@code --role-arn}+ * (assume-role before minting, in either the subcommand's own long form or the abbreviated+ * form {@code update-kubeconfig --role-arn} actually writes) and {@code aws-iam-authenticator+ * token} are not supported and are rejected explicitly rather than silently mishandled.+ *+ * <p>Credentials are resolved from {@code AWS_ACCESS_KEY_ID}/{@code AWS_SECRET_ACCESS_KEY}/+ * {@code AWS_SESSION_TOKEN}, else the {@code AWS_PROFILE} (default {@code default}) section of+ * the shared credentials file ({@code AWS_SHARED_CREDENTIALS_FILE}, else {@code+ * ~/.aws/credentials}). Unlike plain env-var precedence, an {@code AWS_PROFILE} the kubeconfig+ * exec block's own {@code env} entries name explicitly (how {@code aws eks update-kubeconfig+ * --profile <p>} selects one) is honored ahead of static keys that merely happen to be ambient+ * in Floci's own process; only keys the exec block itself sets take precedence over that+ * profile. The SSO/IMDS/container-credentials/IRSA legs of the SDK's default chain are not+ * implemented.+ */+final class EksTokenMinter {++ private static final String CLUSTER_ID_HEADER = "x-k8s-aws-id";+ private static final String TOKEN_PREFIX = "k8s-aws-v1.";+ /**+ * The {@code X-Amz-Expires} query value, matching aws-iam-authenticator's token generator.+ * STS currently ignores this value for {@code GetCallerIdentity}; the token's real validity+ * is {@link #TOKEN_VALIDITY_SECONDS}, enforced by the verifying webhook off {@code X-Amz-Date}+ * instead. Kept at parity with the reference implementation rather than raised, since a+ * larger value here has no verified effect and isn't what real callers actually send.+ */+ private static final int PRESIGN_QUERY_EXPIRES_SECONDS = 60;+ /** Real token validity: aws-iam-authenticator's verifier treats every token as good for 15 minutes. */+ private static final int TOKEN_VALIDITY_SECONDS = 15 * 60;+ /** Re-mint this long before the token's real validity would expire, for clock-skew slack. */+ private static final int REFRESH_MARGIN_SECONDS = 60;+ private static final String EMPTY_BODY_SHA256 =+ "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";+ private static final DateTimeFormatter AMZ_DATE =+ DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);+ private static final DateTimeFormatter AMZ_DATE_STAMP =+ DateTimeFormatter.ofPattern("yyyyMMdd").withZone(ZoneOffset.UTC);++ private EksTokenMinter() {+ }++ /**+ * Returns a caching token supplier if {@code exec} is a recognized {@code aws eks get-token}+ * invocation, or empty if it is some other exec/auth-provider plugin this class does not+ * handle. When the shape is recognized but a required piece (cluster name, region) is+ * missing or unsupported ({@code --role-arn}), throws immediately rather than returning+ * empty, so the caller gets a specific error instead of the generic "exec not supported" one.+ */+ static Optional<Supplier<String>> tokenSupplierIfRecognized(JsonNode exec) {+ if (!isAwsEksGetToken(exec)) {+ return Optional.empty();+ }+ var execEnv = execEnv(exec);+ UnaryOperator<String> env = name -> execEnv.getOrDefault(name, System.getenv(name));+ var args = parseArgs(exec, env);+ return Optional.of(new CachingTokenSupplier(args.clusterName(), args.region(), execEnv));+ }++ /**+ * Kubeconfig lets an exec plugin declare extra environment variables under {@code exec.env}+ * (a list of {@code {name, value}} pairs). This is how {@code aws eks update-kubeconfig+ * --profile <p>} propagates the profile it was run with, since the exec plugin would+ * otherwise be a subprocess with no reason to inherit it. We don't spawn a subprocess, but+ * we still need to honor these entries ahead of Floci's own process environment, or a+ * profile-scoped kubeconfig silently resolves the wrong AWS identity.+ */+ private static Map<String, String> execEnv(JsonNode exec) {+ var envNode = exec.path("env");+ if (!envNode.isArray()) {+ return Map.of();+ }+ var result = new LinkedHashMap<String, String>();+ for (var entry : envNode) {+ var name = entry.path("name").asText(null);+ var value = entry.path("value").asText(null);+ if (name != null && value != null) {+ result.put(name, value);+ }+ }+ return result;+ }++ static boolean isAwsEksGetToken(JsonNode exec) {+ var command = exec.path("command").asText("");+ if (command.isBlank()) {+ return false;+ }+ var fileName = Path.of(command).getFileName();+ var commandName = fileName == null ? command : fileName.toString();+ if (!"aws".equals(commandName)) {+ return false;+ }+ return findSubcommandIndex(exec.path("args")) >= 0;+ }++ /**+ * Finds {@code "eks", "get-token"} as a consecutive pair anywhere in {@code args}, not just+ * at the front. {@code aws eks update-kubeconfig} always generates {@code --region <region>+ * eks get-token --cluster-name <name> --output json}, i.e. a global option ahead of the+ * subcommand (confirmed against the AWS CLI's own {@code update_kubeconfig.py}), so a+ * strictly-positional check would reject every kubeconfig that tool actually produces.+ */+ private static int findSubcommandIndex(JsonNode args) {+ if (!args.isArray()) {+ return -1;+ }+ for (var i = 0; i + 1 < args.size(); i++) {+ if ("eks".equals(args.get(i).asText()) && "get-token".equals(args.get(i + 1).asText())) {+ return i;+ }+ }+ return -1;+ }++ record ExecArgs(String clusterName, String region) {+ }++ /**+ * Assumes {@link #isAwsEksGetToken(JsonNode)} already returned true for {@code exec}.+ * {@code env} is injected (rather than reading {@link System#getenv(String)} directly) so+ * the region fallback is deterministically testable regardless of the host's own environment.+ */+ static ExecArgs parseArgs(JsonNode exec, UnaryOperator<String> env) {+ var args = exec.path("args");+ var subcommandIndex = findSubcommandIndex(args);+ String clusterName = null;+ String region = null;+ for (var i = 0; i < args.size(); i++) {+ if (i == subcommandIndex || i == subcommandIndex + 1) {+ continue;+ }+ var arg = args.get(i).asText();+ if (isRoleOption(arg)) {+ throw new IllegalStateException(+ "kubeconfig exec plugin 'aws eks get-token --role-arn' is not supported: the "+ + "kubernetes Lambda executor only mints a token for its own resolved "+ + "credentials, not an assumed role. Point --cluster-name at credentials "+ + "that already have cluster access.");+ }+ if (("--cluster-name".equals(arg) || "--region".equals(arg)) && i + 1 < args.size()) {+ var value = args.get(++i).asText();+ if ("--cluster-name".equals(arg)) {+ clusterName = value;+ } else {+ region = value;+ }+ }+ }+ if (clusterName == null || clusterName.isBlank()) {+ throw new IllegalStateException(+ "kubeconfig exec plugin 'aws eks get-token' has no --cluster-name argument");+ }+ if (region == null || region.isBlank()) {+ region = env.apply("AWS_REGION");+ }+ if (region == null || region.isBlank()) {+ region = env.apply("AWS_DEFAULT_REGION");+ }+ if (region == null || region.isBlank()) {+ throw new IllegalStateException(+ "kubeconfig exec plugin 'aws eks get-token --cluster-name " + clusterName+ + "' has no region: pass --region, or set AWS_REGION/AWS_DEFAULT_REGION.");+ }+ return new ExecArgs(clusterName, region);+ }++ /**+ * {@code aws eks get-token}'s own flag is {@code --role-arn}, but {@code aws eks+ * update-kubeconfig --role-arn <arn>} writes the abbreviated {@code --role} into the+ * kubeconfig it generates (confirmed against the AWS CLI source). More generally, AWS CLI's+ * argument parser accepts any unambiguous prefix of a long option, and {@code role-arn} is+ * the only {@code get-token} option starting with "role", so {@code --role-a} and+ * {@code --role-ar} are just as valid to a real invocation as {@code --role} itself. Matching+ * only the one abbreviation actually seen in generated output, rather than the full prefix+ * range, would leave the others free to silently mint a token with ambient or profile+ * credentials instead of the requested role: a wrong-identity bug, not a merely+ * unsupported-shape one. So every prefix from {@code --role} through {@code --role-arn},+ * with or without a {@code --flag=value} suffix, is rejected explicitly.+ */+ private static boolean isRoleOption(String arg) {+ var name = arg.split("=", 2)[0];+ return name.length() >= "--role".length() && "--role-arn".startsWith(name);+ }++ private static final class CachingTokenSupplier implements Supplier<String> {+ private final String clusterName;+ private final String region;+ private final Map<String, String> execEnv;+ private String token;+ private Instant expiresAt = Instant.EPOCH;++ private CachingTokenSupplier(String clusterName, String region, Map<String, String> execEnv) {+ this.clusterName = clusterName;+ this.region = region;+ this.execEnv = execEnv;+ }++ @Override+ public synchronized String get() {+ var now = Instant.now();+ if (token == null || !now.isBefore(expiresAt.minusSeconds(REFRESH_MARGIN_SECONDS))) {+ token = mint(clusterName, region, execEnv);+ expiresAt = now.plusSeconds(TOKEN_VALIDITY_SECONDS);+ }+ return token;+ }+ }++ private static String mint(String clusterName, String region, Map<String, String> execEnv) {+ return mint(clusterName, region, resolveCredentials(execEnv, System::getenv), Clock.systemUTC());+ }++ /** Package-visible so the signing math is testable with fixed credentials, no env/file I/O. */+ static String mint(String clusterName, String region, AwsCredentials credentials) {+ return mint(clusterName, region, credentials, Clock.systemUTC());+ }++ /**+ * Package-visible so the signing math is testable against a fixed, independently-verifiable+ * timestamp: with a real clock, X-Amz-Date changes every call, so the resulting signature+ * can only ever be checked for shape, never against a hard-coded expected value.+ */+ static String mint(String clusterName, String region, AwsCredentials credentials, Clock clock) {+ var now = clock.instant();+ var amzDate = AMZ_DATE.format(now);+ var dateStamp = AMZ_DATE_STAMP.format(now);+ var host = stsHost(region);+ var credentialScope = dateStamp + "/" + region + "/sts/aws4_request";+ var signedHeaders = "host;" + CLUSTER_ID_HEADER;++ var queryParams = new TreeMap<String, String>();+ queryParams.put("Action", "GetCallerIdentity");+ queryParams.put("Version", "2011-06-15");+ queryParams.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");+ queryParams.put("X-Amz-Credential", credentials.accessKeyId() + "/" + credentialScope);+ queryParams.put("X-Amz-Date", amzDate);+ queryParams.put("X-Amz-Expires", String.valueOf(PRESIGN_QUERY_EXPIRES_SECONDS));+ queryParams.put("X-Amz-SignedHeaders", signedHeaders);+ if (credentials.sessionToken() != null && !credentials.sessionToken().isBlank()) {+ queryParams.put("X-Amz-Security-Token", credentials.sessionToken());+ }++ var canonicalQueryString = queryParams.entrySet().stream()+ .map(e -> uriEncode(e.getKey()) + "=" + uriEncode(e.getValue()))+ .collect(Collectors.joining("&"));++ // Sorted by header name ("host" < "x-k8s-aws-id"), matching X-Amz-SignedHeaders above.+ var canonicalHeaders = "host:" + host + "\n" + CLUSTER_ID_HEADER + ":" + clusterName + "\n";+ var canonicalRequest = "GET\n/\n" + canonicalQueryString + "\n"+ + canonicalHeaders + "\n" + signedHeaders + "\n" + EMPTY_BODY_SHA256;++ var stringToSign = "AWS4-HMAC-SHA256\n" + amzDate + "\n" + credentialScope + "\n"+ + sha256Hex(canonicalRequest);+ var signingKey = deriveSigningKey(credentials.secretAccessKey(), dateStamp, region, "sts");+ var signature = hexEncode(hmacSha256(signingKey, stringToSign));++ var url = "https://" + host + "/?" + canonicalQueryString + "&X-Amz-Signature=" + signature;+ return TOKEN_PREFIX + Base64.getUrlEncoder().withoutPadding()+ .encodeToString(url.getBytes(StandardCharsets.UTF_8));+ }++ record AwsCredentials(String accessKeyId, String secretAccessKey, String sessionToken) {+ }++ /** Maps a region to its STS hostname, honoring the region's actual partition. */+ private static String stsHost(String region) {+ return "sts." + region + "." + partitionDnsSuffix(region);+ }++ /**+ * Sourced from the AWS SDKs' own public partition metadata (e.g. botocore's+ * {@code partitions.json}, MIT-licensed and openly published at+ * https://github.com/boto/botocore/blob/develop/botocore/data/partitions.json), rather than+ * assumed. Covers every partition that metadata currently defines: the commercial+ * {@code aws} partition and {@code aws-us-gov} share {@code amazonaws.com} so neither needs+ * a case of its own, {@code aws-cn} is the one commonly-hit split, and the classified+ * ISO/ISOB/ISOE/ISOF partitions (regions matching {@code us-iso-*}, {@code us-isob-*},+ * {@code eu-isoe-*}, {@code us-isof-*}) each resolve under their own distinct domain.+ */+ private static String partitionDnsSuffix(String region) {+ if (region.matches("cn-\\w+-\\d+")) {+ return "amazonaws.com.cn";+ }+ if (region.matches("us-iso-\\w+-\\d+")) {+ return "c2s.ic.gov";+ }+ if (region.matches("us-isob-\\w+-\\d+")) {+ return "sc2s.sgov.gov";+ }+ if (region.matches("eu-isoe-\\w+-\\d+")) {+ return "cloud.adc-e.uk";+ }+ if (region.matches("us-isof-\\w+-\\d+")) {+ return "csp.hci.ic.gov";+ }+ if (region.matches("eusc-de-\\w+-\\d+")) {+ return "amazonaws.eu";+ }+ return "amazonaws.com";+ }++ /**+ * {@code execEnv} (the kubeconfig exec block's own {@code env} entries, not merged with+ * Floci's process environment) is consulted as a unit before falling back to plain env-var+ * precedence. {@code aws eks update-kubeconfig --profile <p>} selects a profile by writing+ * exactly {@code AWS_PROFILE} into exec.env, a specific instruction for this resolution; if+ * static keys that merely happen to be ambient in Floci's own process were allowed to+ * outrank it (as flat "env vars beat profile" precedence would normally do), a profile-scoped+ * kubeconfig would silently authenticate as the wrong principal instead of failing loudly or+ * using the profile it named.+ */+ static AwsCredentials resolveCredentials(Map<String, String> execEnv, UnaryOperator<String> ambientEnv) {+ UnaryOperator<String> env = name -> execEnv.getOrDefault(name, ambientEnv.apply(name));++ if (hasPairedKeys("exec.env", execEnv.get("AWS_ACCESS_KEY_ID"), execEnv.get("AWS_SECRET_ACCESS_KEY"))) {+ // The session token must come from exec.env too, not the merged (execEnv-or-ambient)+ // lookup: a session token is only valid for the specific access/secret key pair STS+ // issued it alongside, so pairing exec.env's static keys with an unrelated session+ // token that merely happens to be ambient in Floci's own process would sign with a+ // key/token combination STS never issued together, and reject the request.+ return new AwsCredentials(execEnv.get("AWS_ACCESS_KEY_ID"), execEnv.get("AWS_SECRET_ACCESS_KEY"),+ execEnv.get("AWS_SESSION_TOKEN"));+ }+ if (execEnv.containsKey("AWS_PROFILE")) {+ return resolveFromSharedCredentialsFile(env, execEnv.get("AWS_PROFILE"));+ }++ // execEnv has neither key at this point (the check above already rejected exactly one+ // being present), so these are necessarily ambient-sourced; the session token must be+ // too, for the same reason as the exec.env branch above.+ var accessKeyId = ambientEnv.apply("AWS_ACCESS_KEY_ID");+ var secretAccessKey = ambientEnv.apply("AWS_SECRET_ACCESS_KEY");+ if (hasPairedKeys("the environment", accessKeyId, secretAccessKey)) {+ return new AwsCredentials(accessKeyId, secretAccessKey, ambientEnv.apply("AWS_SESSION_TOKEN"));+ }+ return resolveFromSharedCredentialsFile(env, env.apply("AWS_PROFILE"));+ }++ /**+ * True if both keys are present, false if both are absent, and throws if exactly one is:+ * matching botocore's own env-credential provider, which raises {@code PartialCredentialsError}+ * for a lone access key or secret key rather than treating it as "absent, fall through to the+ * next provider." Silently falling through here (e.g. to a profile named alongside a broken+ * key pair) would mint a token under a different identity than whatever the caller actually+ * intended to supply.+ */+ private static boolean hasPairedKeys(String source, String accessKeyId, String secretAccessKey) {+ var hasAccessKeyId = accessKeyId != null && !accessKeyId.isBlank();+ var hasSecretAccessKey = secretAccessKey != null && !secretAccessKey.isBlank();+ if (hasAccessKeyId != hasSecretAccessKey) {+ throw new IllegalStateException(+ "Partial AWS credentials in " + source + ": "+ + (hasAccessKeyId ? "AWS_ACCESS_KEY_ID is set but AWS_SECRET_ACCESS_KEY is not"+ : "AWS_SECRET_ACCESS_KEY is set but AWS_ACCESS_KEY_ID is not")+ + ". Set both, or neither.");+ }+ return hasAccessKeyId;+ }++ private static AwsCredentials resolveFromSharedCredentialsFile(UnaryOperator<String> env, String profileEnv) {+ var pathValue = env.apply("AWS_SHARED_CREDENTIALS_FILE");+ var path = (pathValue != null && !pathValue.isBlank())+ ? Path.of(pathValue)+ : Path.of(System.getProperty("user.home"), ".aws", "credentials");+ if (!Files.exists(path)) {+ throw new IllegalStateException(+ "Could not resolve AWS credentials to mint an EKS token: no AWS_ACCESS_KEY_ID/"+ + "AWS_SECRET_ACCESS_KEY in the environment and no shared credentials file at "+ + path + ". Set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY, or "+ + "AWS_SHARED_CREDENTIALS_FILE.");+ }+ var profile = (profileEnv == null || profileEnv.isBlank()) ? "default" : profileEnv;+ var section = readIniSection(path, profile);+ var accessKeyId = section.get("aws_access_key_id");+ var secretAccessKey = section.get("aws_secret_access_key");+ if (accessKeyId == null || secretAccessKey == null) {+ throw new IllegalStateException(+ "AWS credentials profile '" + profile + "' in " + path+ + " has no aws_access_key_id/aws_secret_access_key");+ }+ return new AwsCredentials(accessKeyId, secretAccessKey, section.get("aws_session_token"));+ }++ private static Map<String, String> readIniSection(Path path, String profile) {+ var target = "[" + profile + "]";+ var result = new LinkedHashMap<String, String>();+ try {+ var inSection = false;+ for (var raw : Files.readAllLines(path, StandardCharsets.UTF_8)) {+ var line = raw.strip();+ if (line.isEmpty() || line.startsWith("#") || line.startsWith(";")) {+ continue;+ }+ if (line.startsWith("[") && line.endsWith("]")) {+ inSection = line.equals(target);+ continue;+ }+ if (!inSection) {+ continue;+ }+ var eq = line.indexOf('=');+ if (eq > 0) {+ result.put(line.substring(0, eq).strip(), line.substring(eq + 1).strip());+ }+ }+ } catch (IOException e) {+ throw new IllegalStateException("Could not read AWS credentials file " + path + ": " + e.getMessage(), e);+ }+ if (result.isEmpty()) {+ throw new IllegalStateException("AWS credentials profile '" + profile + "' not found in " + path);+ }+ return result;+ }++ /** RFC 3986 percent-encoding, byte-wise over UTF-8, per the SigV4 spec (not {@link java.net.URLEncoder}). */+ private static String uriEncode(String input) {+ var result = new StringBuilder();+ for (var b : input.getBytes(StandardCharsets.UTF_8)) {+ var c = (char) (b & 0xFF);+ if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')+ || c == '-' || c == '_' || c == '.' || c == '~') {+ result.append(c);+ } else {+ result.append('%').append(String.format("%02X", b & 0xFF));+ }+ }+ return result.toString();+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region, String service) {+ var kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ var kDate = hmacSha256(kSecret, date);+ var kRegion = hmacSha256(kDate, region);+ var kService = hmacSha256(kRegion, service);+ return hmacSha256(kService, "aws4_request");+ }++ private static byte[] hmacSha256(byte[] key, String data) {+ try {+ var mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("Could not compute HMAC-SHA256: " + e.getMessage(), e);+ }+ }++ private static String sha256Hex(String input) {+ try {+ var digest = MessageDigest.getInstance("SHA-256");+ return hexEncode(digest.digest(input.getBytes(StandardCharsets.UTF_8)));+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("Could not compute SHA-256: " + e.getMessage(), e);+ }+ }++ private static String hexEncode(byte[] bytes) {+ var sb = new StringBuilder(bytes.length * 2);+ for (var b : bytes) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.javaindex e55a9408ae..36b135395a 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.java@@ -65,8 +65,10 @@ import java.util.stream.Collectors;* {@code ~/.kube/config}), current-context only, with a static bearer token or a* client-certificate/client-key credential (PKCS#8 only). {@code insecure-skip-tls-verify}* is honored (skips both chain and hostname validation, matching kubectl), which covers- * most kind/minikube configs. exec/auth-provider plugins (e.g. {@code aws eks get-token})- * are not supported and fail with a clear error.</li>+ * most kind/minikube configs. The {@code aws eks get-token --cluster-name <name>} exec+ * plugin is also recognized and its token minted natively, see {@link EksTokenMinter};+ * any other exec command, {@code --role-arn}, or an auth-provider plugin (e.g. gcloud)+ * is not supported and fails with a clear error.</li>* </ul>*/@ApplicationScoped@@ -371,12 +373,17 @@ public class KubernetesApiClient {}var token = user.path("token").asText(null);- if (token == null && keyManagers == null) {+ Supplier<String> execTokenSupplier = user.has("exec")+ ? EksTokenMinter.tokenSupplierIfRecognized(user.path("exec")).orElse(null)+ : null;+ if (token == null && keyManagers == null && execTokenSupplier == null) {if (user.has("exec") || user.has("auth-provider")) {throw new IllegalStateException("kubeconfig user '" + userName + "' uses an exec or auth-provider credential "- + "plugin, which the kubernetes Lambda executor does not support. Use a "- + "static token or client-certificate/client-key credential instead.");+ + "plugin the kubernetes Lambda executor does not recognize (only 'aws eks "+ + "get-token --cluster-name <name> [--region <region>]' is supported). Use "+ + "a static token, client-certificate/client-key credential, or that exec "+ + "shape instead.");}throw new IllegalStateException("kubeconfig user '" + userName+ "' has no supported credential (token or client-certificate/client-key) in " + path);@@ -394,7 +401,8 @@ public class KubernetesApiClient {httpBuilder.sslParameters(sslParameters);}this.http = httpBuilder.build();- this.tokenSupplier = token == null ? null : () -> token;+ this.tokenSupplier = execTokenSupplier != null ? execTokenSupplier+ : token == null ? null : () -> token;}private static Path kubeconfigPath() {diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinterTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinterTest.javanew file mode 100644index 0000000000..4ea87bb430--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinterTest.java@@ -0,0 +1,475 @@+package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.net.URI;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;+import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.util.Arrays;+import java.util.Base64;+import java.util.Map;+import java.util.function.UnaryOperator;+import java.util.stream.Collectors;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * Exercises the {@code aws eks get-token} recognition, argument parsing, and the presigned+ * {@code sts:GetCallerIdentity} URL that becomes the bearer token, against fixed credentials so+ * the tests are deterministic regardless of the host's own AWS environment. What can't be+ * checked without a real AWS account (that STS actually accepts the signature) is left to+ * manual verification against a real cluster.+ */+class EksTokenMinterTest {++ private static final EksTokenMinter.AwsCredentials CREDENTIALS =+ new EksTokenMinter.AwsCredentials("AKIAEXAMPLE", "secret", null);++ @Test+ void recognizesAwsEksGetToken() throws Exception {+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster]+ """))).isTrue();+ }++ @Test+ void recognizesAwsFromAnAbsolutePath() throws Exception {+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: /usr/local/bin/aws+ args: [eks, get-token, --cluster-name, my-cluster]+ """))).isTrue();+ }++ @Test+ void doesNotRecognizeOtherCommands() throws Exception {+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: gcloud+ args: [container, clusters, get-credentials]+ """))).isFalse();+ }++ @Test+ void doesNotRecognizeAwsIamAuthenticator() throws Exception {+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: aws-iam-authenticator+ args: [token, -i, my-cluster]+ """))).isFalse();+ }++ @Test+ void doesNotRecognizeOtherAwsSubcommands() throws Exception {+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: aws+ args: [sts, get-caller-identity]+ """))).isFalse();+ }++ @Test+ void recognizesTheShapeAwsEksUpdateKubeconfigActuallyGenerates() throws Exception {+ // Confirmed against the AWS CLI's own update_kubeconfig.py: --region always precedes+ // the subcommand, and --output json always follows -- get-token is never args[0]/[1].+ assertThat(EksTokenMinter.isAwsEksGetToken(execNode("""+ command: aws+ args: [--region, us-west-2, eks, get-token, --cluster-name, my-cluster, --output, json]+ """))).isTrue();+ }++ @Test+ void parsesClusterNameAndRegionFromTheGeneratedShape() throws Exception {+ var args = EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [--region, us-west-2, eks, get-token, --cluster-name, my-cluster, --output, json]+ """), name -> {+ throw new AssertionError("--region is given inline, should not fall back to env");+ });++ assertThat(args.clusterName()).isEqualTo("my-cluster");+ assertThat(args.region()).isEqualTo("us-west-2");+ }++ @Test+ void parsesClusterNameAndExplicitRegion() throws Exception {+ var args = EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, --region, eu-west-1]+ """), name -> {+ throw new AssertionError("should not fall back to env when --region is given");+ });++ assertThat(args.clusterName()).isEqualTo("my-cluster");+ assertThat(args.region()).isEqualTo("eu-west-1");+ }++ @Test+ void fallsBackToAwsRegionEnvVar() throws Exception {+ var args = EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster]+ """), name -> "AWS_REGION".equals(name) ? "ap-south-1" : null);++ assertThat(args.region()).isEqualTo("ap-south-1");+ }++ @Test+ void fallsBackToAwsDefaultRegionEnvVarWhenAwsRegionIsUnset() throws Exception {+ var args = EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster]+ """), name -> "AWS_DEFAULT_REGION".equals(name) ? "ca-central-1" : null);++ assertThat(args.region()).isEqualTo("ca-central-1");+ }++ @Test+ void rejectsMissingClusterName() throws Exception {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --region, us-east-1]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--cluster-name");+ }++ @Test+ void rejectsRoleArn() throws Exception {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, --role-arn, arn:aws:iam::111122223333:role/x]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--role-arn");+ }++ @Test+ void rejectsTheAbbreviatedRoleFlagAwsEksUpdateKubeconfigActuallyGenerates() throws Exception {+ // update_kubeconfig.py writes "--role", not "--role-arn", when --role-arn was passed to+ // update-kubeconfig. Missing this form would silently mint under ambient credentials+ // instead of the requested role, so it must reject exactly like the long form does.+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [--region, us-west-2, eks, get-token, --cluster-name, my-cluster, --output, json, --role, arn:aws:iam::111122223333:role/x]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--role-arn");+ }++ @Test+ void rejectsTheEqualsSignFormOfRoleArn() throws Exception {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, --role-arn=arn:aws:iam::111122223333:role/x]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--role-arn");+ }++ @Test+ void rejectsTheEqualsSignFormOfTheAbbreviatedRoleFlag() throws Exception {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, --role=arn:aws:iam::111122223333:role/x]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--role-arn");+ }++ @Test+ void rejectsIntermediateUnambiguousRoleArnAbbreviations() throws Exception {+ // AWS CLI's argument parser accepts any unambiguous prefix of a long option, and+ // role-arn is the only get-token option starting with "role", so these are just as+ // valid to a real invocation as the --role form update-kubeconfig actually generates.+ for (var abbreviation : new String[]{"--role-a", "--role-ar"}) {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, %s, arn:aws:iam::111122223333:role/x]+ """.formatted(abbreviation)), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("--role-arn");+ }+ }++ @Test+ void rejectsWhenNoRegionIsResolvable() throws Exception {+ assertThatThrownBy(() -> EksTokenMinter.parseArgs(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster]+ """), name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("region");+ }++ @Test+ void mintedTokenDecodesToAWellFormedPresignedGetCallerIdentityUrl() throws Exception {+ var token = EksTokenMinter.mint("my-cluster", "us-west-2", CREDENTIALS);++ assertThat(token).startsWith("k8s-aws-v1.");+ var url = decode(token);+ var uri = URI.create(url);+ var query = parseQuery(uri);++ assertThat(uri.getScheme()).isEqualTo("https");+ assertThat(uri.getHost()).isEqualTo("sts.us-west-2.amazonaws.com");+ assertThat(query.get("Action")).isEqualTo("GetCallerIdentity");+ assertThat(query.get("Version")).isEqualTo("2011-06-15");+ assertThat(query.get("X-Amz-Algorithm")).isEqualTo("AWS4-HMAC-SHA256");+ assertThat(query.get("X-Amz-Credential")).startsWith("AKIAEXAMPLE/").endsWith("/us-west-2/sts/aws4_request");+ assertThat(query.get("X-Amz-Expires")).isEqualTo("60");+ assertThat(query.get("X-Amz-SignedHeaders")).isEqualTo("host;x-k8s-aws-id");+ assertThat(query.get("X-Amz-Signature")).matches("[0-9a-f]{64}");+ assertThat(query).doesNotContainKey("X-Amz-Security-Token");+ }++ @Test+ void mintedSignatureMatchesAnIndependentlyComputedReferenceValue() throws Exception {+ // Fixed inputs, cross-checked against a from-scratch Python re-implementation of the+ // SigV4 spec (not ported from EksTokenMinter's own code, so it can't share a bug with+ // it): canonical request -> string to sign -> HMAC-derived signing key -> signature.+ // Structural assertions elsewhere only prove the token has the right shape; this proves+ // the actual signature bytes are what the spec says they should be for these inputs.+ var credentials = new EksTokenMinter.AwsCredentials(+ "AKIAIOSFODNN7EXAMPLE",+ "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",+ "FQoGZXIvYXdzEXAMPLESESSIONTOKENvaluevaluevalue");+ var clock = Clock.fixed(Instant.parse("2024-01-15T12:00:00Z"), ZoneOffset.UTC);++ var token = EksTokenMinter.mint("my-cluster", "us-west-2", credentials, clock);+ var query = parseQuery(URI.create(decode(token)));++ assertThat(query.get("X-Amz-Date")).isEqualTo("20240115T120000Z");+ assertThat(query.get("X-Amz-Credential"))+ .isEqualTo("AKIAIOSFODNN7EXAMPLE/20240115/us-west-2/sts/aws4_request");+ assertThat(query.get("X-Amz-Signature"))+ .isEqualTo("1f3eff1793d8e9b9ecf0b461c6b40f9aa3029d913ffc70a17b498c932a6c34e1");+ }++ @Test+ void includesSecurityTokenWhenSessionTokenIsPresent() throws Exception {+ var credentials = new EksTokenMinter.AwsCredentials("AKIAEXAMPLE", "secret", "session-token");+ var query = parseQuery(URI.create(decode(EksTokenMinter.mint("my-cluster", "us-west-2", credentials))));++ assertThat(query.get("X-Amz-Security-Token")).isEqualTo("session-token");+ }++ @Test+ void signatureIsBoundToTheClusterName() throws Exception {+ var forClusterA = signatureOf(EksTokenMinter.mint("cluster-a", "us-west-2", CREDENTIALS));+ var forClusterB = signatureOf(EksTokenMinter.mint("cluster-b", "us-west-2", CREDENTIALS));++ // The whole point of x-k8s-aws-id being a signed header: a token minted for one+ // cluster must not verify against another, so the two signatures must differ.+ assertThat(forClusterA).isNotEqualTo(forClusterB);+ }++ @Test+ void signsChinaRegionsAgainstTheChinaStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "cn-north-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.cn-north-1.amazonaws.com.cn");+ }++ @Test+ void signsGovCloudRegionsAgainstTheStandardStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "us-gov-west-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.us-gov-west-1.amazonaws.com");+ }++ @Test+ void signsIsoRegionsAgainstTheIsoStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "us-iso-east-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.us-iso-east-1.c2s.ic.gov");+ }++ @Test+ void signsIsoBRegionsAgainstTheIsoBStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "us-isob-east-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.us-isob-east-1.sc2s.sgov.gov");+ }++ @Test+ void signsIsoERegionsAgainstTheIsoEStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "eu-isoe-west-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.eu-isoe-west-1.cloud.adc-e.uk");+ }++ @Test+ void signsIsoFRegionsAgainstTheIsoFStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "us-isof-south-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.us-isof-south-1.csp.hci.ic.gov");+ }++ @Test+ void signsEuscRegionsAgainstTheEuscStsSuffix() throws Exception {+ var uri = URI.create(decode(EksTokenMinter.mint("my-cluster", "eusc-de-east-1", CREDENTIALS)));++ assertThat(uri.getHost()).isEqualTo("sts.eusc-de-east-1.amazonaws.eu");+ }++ @Test+ void execEnvSuppliesCredentialsAheadOfTheProcessEnvironment() throws Exception {+ var supplier = EksTokenMinter.tokenSupplierIfRecognized(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster, --region, us-west-2]+ env:+ - name: AWS_ACCESS_KEY_ID+ value: AKIAFROMEXECENV+ - name: AWS_SECRET_ACCESS_KEY+ value: secret-from-exec-env+ """)).orElseThrow();++ var query = parseQuery(URI.create(decode(supplier.get())));++ // Proves exec.env, not whatever AWS_ACCESS_KEY_ID happens to be in Floci's own+ // environment, drove credential resolution -- the bug aws eks update-kubeconfig+ // --profile <p> would otherwise trip, since it threads the profile through exec.env.+ assertThat(query.get("X-Amz-Credential")).startsWith("AKIAFROMEXECENV/");+ }++ @Test+ void execEnvProfileTakesPrecedenceOverAmbientStaticKeys(@TempDir Path tempDir) throws Exception {+ var credentialsFile = tempDir.resolve("credentials");+ Files.writeString(credentialsFile, """+ [work]+ aws_access_key_id = AKIAFROMPROFILE+ aws_secret_access_key = secret-from-profile+ """);+ Map<String, String> execEnv = Map.of("AWS_PROFILE", "work");+ // Simulates static keys that merely happen to be ambient in Floci's own process,+ // unrelated to this kubeconfig -- these must not win just because plain env-var+ // precedence would normally put raw keys ahead of a profile.+ UnaryOperator<String> ambientEnv = name -> switch (name) {+ case "AWS_ACCESS_KEY_ID" -> "AKIAAMBIENT";+ case "AWS_SECRET_ACCESS_KEY" -> "ambient-secret";+ case "AWS_SHARED_CREDENTIALS_FILE" -> credentialsFile.toString();+ default -> null;+ };++ var credentials = EksTokenMinter.resolveCredentials(execEnv, ambientEnv);++ assertThat(credentials.accessKeyId()).isEqualTo("AKIAFROMPROFILE");+ }++ @Test+ void execEnvExplicitKeysStillOutrankExecEnvProfile() throws Exception {+ Map<String, String> execEnv = Map.of(+ "AWS_PROFILE", "work",+ "AWS_ACCESS_KEY_ID", "AKIAFROMEXECENV",+ "AWS_SECRET_ACCESS_KEY", "secret-from-exec-env");++ var credentials = EksTokenMinter.resolveCredentials(execEnv, name -> null);++ assertThat(credentials.accessKeyId()).isEqualTo("AKIAFROMEXECENV");+ }++ @Test+ void execEnvExplicitKeysDoNotInheritAnUnrelatedAmbientSessionToken() throws Exception {+ // A session token is only valid for the specific key pair STS issued it with. If+ // exec.env supplies static keys but no session token, an ambient one (left over from+ // some unrelated temporary credential set in Floci's own process) must not get+ // attached, or the mismatched key/token combination gets rejected by STS.+ Map<String, String> execEnv = Map.of(+ "AWS_ACCESS_KEY_ID", "AKIAFROMEXECENV",+ "AWS_SECRET_ACCESS_KEY", "secret-from-exec-env");+ UnaryOperator<String> ambientEnv = name -> "AWS_SESSION_TOKEN".equals(name) ? "unrelated-ambient-token" : null;++ var credentials = EksTokenMinter.resolveCredentials(execEnv, ambientEnv);++ assertThat(credentials.sessionToken()).isNull();+ }++ @Test+ void ambientKeysDoNotInheritAnUnrelatedExecEnvSessionToken() throws Exception {+ // Symmetric case: exec.env names a session token but no keys of its own (nothing real+ // generates this, but the risk is the same either direction), so the keys resolved+ // from the ambient environment must not pick it up either.+ Map<String, String> execEnv = Map.of("AWS_SESSION_TOKEN", "exec-env-only-token");+ UnaryOperator<String> ambientEnv = name -> switch (name) {+ case "AWS_ACCESS_KEY_ID" -> "AKIAAMBIENT";+ case "AWS_SECRET_ACCESS_KEY" -> "ambient-secret";+ default -> null;+ };++ var credentials = EksTokenMinter.resolveCredentials(execEnv, ambientEnv);++ assertThat(credentials.sessionToken()).isNull();+ }++ @Test+ void rejectsAPartialExecEnvKeyPairRatherThanFallingThroughToTheProfile() throws Exception {+ // AWS_ACCESS_KEY_ID with no AWS_SECRET_ACCESS_KEY alongside AWS_PROFILE is a broken+ // config, not "no explicit keys, use the profile" -- silently falling through here+ // would mint a token under a different identity than intended.+ Map<String, String> execEnv = Map.of(+ "AWS_PROFILE", "work",+ "AWS_ACCESS_KEY_ID", "AKIAFROMEXECENV");++ assertThatThrownBy(() -> EksTokenMinter.resolveCredentials(execEnv, name -> null))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("AWS_SECRET_ACCESS_KEY");+ }++ @Test+ void rejectsAPartialAmbientKeyPairRatherThanFallingThroughToTheSharedCredentialsFile() throws Exception {+ UnaryOperator<String> ambientEnv = name -> "AWS_SECRET_ACCESS_KEY".equals(name) ? "ambient-secret" : null;++ assertThatThrownBy(() -> EksTokenMinter.resolveCredentials(Map.of(), ambientEnv))+ .isInstanceOf(IllegalStateException.class)+ .hasMessageContaining("AWS_ACCESS_KEY_ID");+ }++ @Test+ void execEnvSuppliesRegionFallbackAheadOfTheProcessEnvironment() throws Exception {+ var supplier = EksTokenMinter.tokenSupplierIfRecognized(execNode("""+ command: aws+ args: [eks, get-token, --cluster-name, my-cluster]+ env:+ - name: AWS_REGION+ value: eu-central-1+ - name: AWS_ACCESS_KEY_ID+ value: AKIAFROMEXECENV+ - name: AWS_SECRET_ACCESS_KEY+ value: secret-from-exec-env+ """)).orElseThrow();++ var uri = URI.create(decode(supplier.get()));++ assertThat(uri.getHost()).isEqualTo("sts.eu-central-1.amazonaws.com");+ }++ private static String signatureOf(String token) throws Exception {+ return parseQuery(URI.create(decode(token))).get("X-Amz-Signature");+ }++ private static String decode(String token) {+ assertThat(token).startsWith("k8s-aws-v1.");+ return new String(Base64.getUrlDecoder().decode(token.substring("k8s-aws-v1.".length())),+ StandardCharsets.UTF_8);+ }++ private static Map<String, String> parseQuery(URI uri) {+ return Arrays.stream(uri.getRawQuery().split("&"))+ .map(pair -> pair.split("=", 2))+ .collect(Collectors.toMap(+ p -> URLDecoder.decode(p[0], StandardCharsets.UTF_8),+ p -> URLDecoder.decode(p[1], StandardCharsets.UTF_8)));+ }++ private static JsonNode execNode(String yaml) throws Exception {+ return new ObjectMapper(new YAMLFactory()).readTree(yaml);+ }+}