Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(sts): vend a signed web identity token for the calling identity (#6517)

Priamo Germosen4c55ec6b77c0
diff --git a/docs/services/index.md b/docs/services/index.md
index f980be76f0..38b6f3d92c 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -24,7 +24,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [API Gateway v1](api-gateway.md) | `/restapis/...` | REST JSON | 80 |
| [API Gateway v2](api-gateway.md#v2) | `/v2/apis/...` | REST JSON | 53 + data-plane |
| [IAM](iam.md) | `POST /` with `Action=` param | Query | 180 |
-| [STS](sts.md) | `POST /` with `Action=` param | Query | 10 |
+| [STS](sts.md) | `POST /` with `Action=` param | Query | 11 |
| [AWS Sign-In](iam.md#aws-sign-in-login-credentials) | `/v1/authorize`, `/v1/token` | REST JSON | 2 |
| [Organizations](organizations.md) | `POST /` + `X-Amz-Target: AWSOrganizationsV20161128.*` | JSON 1.1 | 56 |
| [Cognito](cognito.md) | `POST /` + `X-Amz-Target: AWSCognitoIdentityProviderService.*` | JSON 1.1 | 90 |
diff --git a/docs/services/sts.md b/docs/services/sts.md
index 8e54ed1502..1f1f2757b5 100644
--- a/docs/services/sts.md
+++ b/docs/services/sts.md
@@ -16,6 +16,7 @@
| `GetDelegatedAccessToken` | Exchange a delegation request's trade-in token for temporary credentials |
| `GetAccessKeyInfo` | Returns the account an access key ID belongs to |
| `AssumeRoot` | Opens a privileged session on a member account of the organization |
+| `GetWebIdentityToken` | Returns a signed JWT representing the calling identity |
## Privileged Root Sessions
@@ -99,6 +100,60 @@ Only the account that filed the delegation request may exchange its token; any o
stating it is not populated for this operation. See the delegation request section of the
[IAM service doc](iam.md) for the lifecycle that issues the token.
+## Web Identity Tokens
+
+`GetWebIdentityToken` answers "a signed JSON Web Token (JWT) that represents the calling AWS
+identity", for authenticating to an external service that supports OIDC discovery. The issuer is
+IAM's: outbound web identity federation mints one issuer URL per account, and the token names it as
+`iss`, so the operation reads the switch behind that URL and answers
+`OutboundWebIdentityFederationDisabledException` while the feature is off rather than IAM's own
+`FeatureDisabled`. The declared constraints are read ahead of the switch, as everywhere else in
+this package: `Audience` is required and holds 1 to 10 audiences of 1 to 1000 characters,
+`SigningAlgorithm` is required at a fixed length of 5, `DurationSeconds` is 60 to 3600 and defaults
+to 300, and `Tags` is at most 50 tags whose keys and values carry their own lengths and pattern. An
+audience sent empty is an audience that is present, so it breaks the minimum length rather than
+reading as absent.
+
+A session cannot outlive itself. `SessionDurationEscalationException` is what a caller holding
+temporary credentials gets when the requested duration would run past the moment its own session
+ends, which is the sentence the reference gives that error: "You cannot use this operation to
+extend the lifetime of a session beyond what was granted when the session was originally created."
+A long-term key names no session and is bounded only by the 3600-second maximum.
+
+A temporary credential with no live session behind it is refused with `ExpiredTokenException`, the
+wording the enforcement filter answers for an expired session, rather than read as a caller Floci
+cannot identify. An unresolvable caller is the account root stand-in elsewhere in this package,
+which is what `GetCallerIdentity` answers for an unknown key, and a token is not a request: its
+subject is signed and outlives the call, so a session that has already gone does not get one
+naming the account root. An unknown long-term key keeps the stand-in.
+
+The claim layout is the one the IAM User Guide publishes. The standard OIDC claims sit at the top
+level, `iss`, `aud`, `sub`, `iat`, `exp` and `jti`, with the caller's ARN as the subject, and the
+custom claims are nested under the `https://sts.amazonaws.com/` namespace: `aws_account` for the
+account the token was asked for, `source_region` for the region it was asked from, and the
+request's tags under `request_tags`. The guide notes that "all these claims may not be present in
+a token at the same time", so the organization, principal tag and session context claims it also
+lists are left out rather than invented, and `request_tags` is absent from a token whose request
+named no tags. The nesting is what keeps a tag off a claim STS sets, a tag named `exp` being a key
+under `request_tags` rather than the claim that chooses the token's lifetime.
+
+Two answers here are Floci's readings. `jwtAlgorithmType` publishes a fixed length of 5 and no enum, so a
+five-character value that is neither `RS256` nor `ES384` is answered with the enum violation this
+package renders for a value outside a documented set, the two values coming from the reference
+rather than from the model. The global endpoint is refused because the reference says "The
+GetWebIdentityToken API is not available on the STS Global endpoint" without giving the refusal, so
+it borrows the wording AWS publishes for `AssumeRoot`; a request to a local host names no such
+endpoint and is not refused. `JWTPayloadSizeExceededException` is modelled and nothing published
+says what the maximum payload is, so no size is invented here to refuse a request with.
+
+The signing key is the account's, minted on first use per algorithm and stored, so a restart does
+not invalidate a token already handed out. `RS256` signs with a 2048-bit RSA key and `ES384` with
+P-384, whose signature is the raw `R || S` pair JWS defines rather than the DER sequence a default
+ECDSA signer returns. What is not here yet is the other half of the feature: nothing publishes the
+verification key, so the `/.well-known/openid-configuration` and `/.well-known/jwks.json` documents
+the issuer URL would host are not served, and a relying party cannot verify one of these tokens
+against this emulator.
+
## Configuration
| Variable | Default | Description |
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/CompactJws.java b/src/main/java/io/github/hectorvent/floci/core/common/CompactJws.java
new file mode 100644
index 0000000000..2a0c9b4d20
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/core/common/CompactJws.java
@@ -0,0 +1,43 @@
+package io.github.hectorvent.floci.core.common;
+
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.PrivateKey;
+import java.security.Signature;
+
+/**
+ * Signs a compact JWS, the {@code header.payload.signature} form a JWT travels in. The header and
+ * the claim set arrive already serialized, so what belongs to one service's token stays with that
+ * service and only the assembly is shared.
+ *
+ * <p>Each part is base64url without padding, which is what JWS requires and what {@link Base64Url}
+ * produces. An ECDSA signature has to be the raw {@code R || S} pair rather than the DER sequence
+ * {@code SHA384withECDSA} returns, so an ECDSA caller names the JDK's {@code ...inP1363Format}
+ * variant, which produces that pair directly and leaves nothing to re-encode here.
+ */
+public final class CompactJws {
+
+ private CompactJws() {
+ }
+
+ /**
+ * The signed token for a serialized {@code header} and {@code claims}, where {@code algorithm}
+ * is the JCA signature name for the {@code alg} the header declares.
+ */
+ public static String sign(byte[] header, byte[] claims, PrivateKey key, String algorithm) {
+ String signingInput = Base64Url.encode(header) + "." + Base64Url.encode(claims);
+ return signingInput + "." + Base64Url.encode(signature(signingInput, key, algorithm));
+ }
+
+ private static byte[] signature(String signingInput, PrivateKey key, String algorithm) {
+ try {
+ Signature signature = Signature.getInstance(algorithm);
+ signature.initSign(key);
+ signature.update(signingInput.getBytes(StandardCharsets.UTF_8));
+ return signature.sign();
+ } catch (GeneralSecurityException e) {
+ throw new IllegalStateException(
+ "Signing a compact JWS with " + algorithm + " failed", e);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java
index 15bb5fa718..1ca56e1f30 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java
@@ -97,8 +97,11 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
private static final String S3_INVALID_ACCESS_KEY_ID =
"The AWS Access Key Id you provided does not exist in our records.";
- /** AWS's wording for temporary credentials past their expiration. */
- private static final String EXPIRED_TOKEN = "The security token included in the request has expired.";
+ /**
+ * AWS's wording for temporary credentials past their expiration, shared with an operation that
+ * finds the session gone after this filter has let the request through.
+ */
+ public static final String EXPIRED_TOKEN = "The security token included in the request has expired.";
/** S3's wording for the same. */
private static final String S3_EXPIRED_TOKEN = "The provided token has expired.";
diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksOidcService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksOidcService.java
index 30477c3919..c24bf4eb63 100644
--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksOidcService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksOidcService.java
@@ -6,7 +6,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.core.common.AwsEndpoints;
import io.github.hectorvent.floci.core.common.AwsException;
-import io.github.hectorvent.floci.core.common.Base64Url;
+import io.github.hectorvent.floci.core.common.CompactJws;
import io.github.hectorvent.floci.core.common.OidcIssuerKeyLookup;
import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
import io.github.hectorvent.floci.core.storage.StorageBackend;
@@ -16,14 +16,12 @@ import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
-import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
-import java.security.Signature;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
@@ -180,12 +178,9 @@ public class EksOidcService implements OidcIssuerKeyLookup {
long exp = now + lifetime;
String subject = "system:serviceaccount:" + namespace + ":" + serviceAccount;
- String header = Base64Url.encode(writeJson(buildHeader(key.getKeyId())));
- String payload = Base64Url.encode(writeJson(
- buildClaims(issuer, aud, subject, namespace, serviceAccount, now, exp)));
-
- String signingInput = header + "." + payload;
- return signingInput + "." + sign(signingInput, toPrivateKey(key.getPrivateKey()));
+ return CompactJws.sign(writeJson(buildHeader(key.getKeyId())),
+ writeJson(buildClaims(issuer, aud, subject, namespace, serviceAccount, now, exp)),
+ toPrivateKey(key.getPrivateKey()), "SHA256withRSA");
}
private int resolveLifetime(Integer requested) {
@@ -232,17 +227,6 @@ public class EksOidcService implements OidcIssuerKeyLookup {
}
}
- private String sign(String signingInput, PrivateKey privateKey) {
- try {
- Signature signature = Signature.getInstance("SHA256withRSA");
- signature.initSign(privateKey);
- signature.update(signingInput.getBytes(StandardCharsets.UTF_8));
- return Base64Url.encode(signature.sign());
- } catch (GeneralSecurityException e) {
- throw new IllegalStateException("EKS OIDC token signing failed", e);
- }
- }
-
RSAPublicKey toPublicKey(String encoded) {
try {
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(encoded));
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.java
index f3197b2c27..1b87fd7112 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
@@ -3092,6 +3092,18 @@ public class IamService implements SessionAccountLookup, ResourceProvider {
}
}
+ /**
+ * The account's federation state while the feature is on, for a caller that answers its own
+ * refusal rather than IAM's: STS turns a token request down with
+ * {@code OutboundWebIdentityFederationDisabledException}, not with {@code FeatureDisabled}.
+ */
+ public Optional<OutboundWebIdentityFederation> findEnabledOutboundWebIdentityFederation() {
+ synchronized (outboundFederationLock) {
+ return outboundFederation.get(OUTBOUND_FEDERATION_KEY)
+ .filter(OutboundWebIdentityFederation::isEnabled);
+ }
+ }
+
/** The issuer URL and whether JWT vending is on, which it is while the feature is enabled. */
public OutboundWebIdentityFederation getOutboundWebIdentityFederationInfo() {
synchronized (outboundFederationLock) {
@@ -4533,6 +4545,15 @@ public class IamService implements SessionAccountLookup, ResourceProvider {
.filter(token -> !token.isBlank());
}
+ /**
+ * When the session a temporary access key belongs to expires, for callers that must not hand
+ * out something outliving it. Empty for a long-term key, which names no session, and for a
+ * session already expired, which no longer resolves.
+ */
+ public Optional<Instant> findSessionExpiration(String accessKeyId) {
+ return currentSession(accessKeyId).map(SessionCredential::getExpiration);
+ }
+
/** Whether an access key ID identifies Floci's documented public deployer credential. */
public boolean isSeededDeployerAccessKey(String accessKeyId) {
return DEFAULT_DEPLOYER_ACCESS_KEY_ID.equals(accessKeyId);
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
index 10f4459dec..63e1e122a0 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.AwsNamespaces;
import io.github.hectorvent.floci.core.common.AwsQueryController;
+import io.github.hectorvent.floci.core.common.AwsQueryLists;
import io.github.hectorvent.floci.core.common.AwsQueryResponse;
import io.github.hectorvent.floci.core.common.AwsRegions;
import io.github.hectorvent.floci.core.common.IamConditionContextResolver;
@@ -19,6 +20,7 @@ import io.github.hectorvent.floci.core.common.XmlBuilder;
import io.github.hectorvent.floci.services.iam.model.DelegationRequest;
import io.github.hectorvent.floci.services.iam.model.IamPolicy;
import io.github.hectorvent.floci.services.iam.model.IamRole;
+import io.github.hectorvent.floci.services.iam.model.OutboundWebIdentityFederation;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Context;
@@ -34,10 +36,14 @@ import java.time.Clock;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
+import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
@@ -60,6 +66,27 @@ public class StsQueryHandler {
/** "the maximum session duration of 900 seconds (15 minutes)", which is also the default here. */
private static final int MAX_ROOT_SESSION_SECONDS = 900;
private static final int MAX_SESSION_TOKEN_SIZE = 4096;
+ /** {@code webIdentityTokenAudienceListType}: 1 to 10 audiences, each 1 to 1000 characters. */
+ private static final int MAX_TOKEN_AUDIENCES = 10;
+ private static final int MAX_TOKEN_AUDIENCE_LENGTH = 1000;
+ /** {@code jwtAlgorithmType} is a fixed length of 5, which both valid values are. */
+ private static final int SIGNING_ALGORITHM_LENGTH = 5;
+ /** {@code tagListType} on this operation: at most 50 tags, each a key and a value. */
+ private static final int MAX_TOKEN_TAGS = 50;
+ private static final int MAX_TAG_KEY_LENGTH = 128;
+ private static final int MAX_TAG_VALUE_LENGTH = 256;
+ /** {@code tagKeyType} and {@code tagValueType} share this pattern, the value allowing empty. */
+ private static final Pattern TAG_PATTERN = Pattern.compile("[\\p{L}\\p{Z}\\p{N}_.:/=+\\-@]+");
+ /** A member of {@code Audience}, capturing the prefix it is named under and its index. */
+ private static final Pattern AUDIENCE_MEMBER =
+ Pattern.compile("(Audience(?:\\.member)?\\.([^.]+))");
+ /** A member of {@code Tags}, which carries its key and its value under that prefix. */
+ private static final Pattern TAG_MEMBER =
+ Pattern.compile("(Tags(?:\\.member)?\\.([^.]+))\\.(?:Key|Value)");
+ /** "If not specified, the default duration is 300 seconds (5 minutes)." */
+ private static final int DEFAULT_TOKEN_SECONDS = 300;
+ private static final int MIN_TOKEN_SECONDS = 60;
+ private static final int MAX_TOKEN_SECONDS = 3600;
private static final String STS_AUDIENCE = "sts.amazonaws.com"; // partition-literal: web-identity audience; no source outside the commercial partition (P9)
private final IamService iamService;
@@ -74,6 +101,7 @@ public class StsQueryHandler {
private final SAMLTrustPolicyEvaluator samlTrustEvaluator;
private final DelegationRequestService delegationRequestService;
private final CentralRootAccess centralRootAccess;
+ private final WebIdentityTokenIssuer tokenIssuer;
private final Clock clock;
/** CSPRNG for session secret keys and session tokens; ordinary IDs keep using {@link ThreadLocalRandom}. */
@@ -94,10 +122,11 @@ public class StsQueryHandler {
SAMLProviderService samlProviderService,
SAMLTrustPolicyEvaluator samlTrustEvaluator,
DelegationRequestService delegationRequestService,
- CentralRootAccess centralRootAccess) {
+ CentralRootAccess centralRootAccess,
+ WebIdentityTokenIssuer tokenIssuer) {
this(iamService, accountResolver, regionResolver, config, trustPolicyEvaluator, webIdentityTrustEvaluator,
tokenVerifier, oidcIssuerKeys, samlProviderService, samlTrustEvaluator, delegationRequestService,
- centralRootAccess, Clock.systemUTC());
+ centralRootAccess, tokenIssuer, Clock.systemUTC());
}
StsQueryHandler(IamService iamService, AccountResolver accountResolver, RegionResolver regionResolver,
@@ -109,6 +138,7 @@ public class StsQueryHandler {
SAMLTrustPolicyEvaluator samlTrustEvaluator,
DelegationRequestService delegationRequestService,
CentralRootAccess centralRootAccess,
+ WebIdentityTokenIssuer tokenIssuer,
Clock clock) {
this.iamService = iamService;
this.accountResolver = accountResolver;
@@ -122,6 +152,7 @@ public class StsQueryHandler {
this.samlTrustEvaluator = samlTrustEvaluator;
this.delegationRequestService = delegationRequestService;
this.centralRootAccess = centralRootAccess;
+ this.tokenIssuer = tokenIssuer;
this.clock = clock;
}
@@ -139,6 +170,7 @@ public class StsQueryHandler {
case "DecodeAuthorizationMessage" -> handleDecodeAuthorizationMessage(params);
case "GetDelegatedAccessToken" -> handleGetDelegatedAccessToken(params);
case "AssumeRoot" -> handleAssumeRoot(params);
+ case "GetWebIdentityToken" -> handleGetWebIdentityToken(params);
default -> AwsQueryResponse.error("UnsupportedOperation",
"Operation " + action + " is not supported by STS.", AwsNamespaces.STS, 400);
};
@@ -958,6 +990,243 @@ public class StsQueryHandler {
return null;
}
+ /**
+ * {@code GetWebIdentityToken} answers "a signed JSON Web Token (JWT) that represents the
+ * calling Amazon Web Services identity", signed by STS and verifiable "using the verification
+ * keys published at the issuer's JWKS endpoint". The issuer is the one IAM mints for the
+ * account when outbound web identity federation is enabled, so this reads the state that
+ * switch keeps and refuses while it is off, with
+ * {@code OutboundWebIdentityFederationDisabledException} rather than IAM's own
+ * {@code FeatureDisabled}.
+ *
+ * <p>The declared constraints are read ahead of all of it: {@code Audience} is 1 to 10 members
+ * of 1 to 1000 characters each and required, {@code SigningAlgorithm} is a fixed length of 5
+ * and required, {@code DurationSeconds} is 60 to 3600 and defaults to 300, and {@code Tags} is
+ * at most 50 tags whose keys and values carry their own lengths and pattern. A member sent
+ * empty is a member that is present, so it breaks its length rather than reading as absent.
+ * The duration keeps this file's own check, which answers the first thing it finds and reports
+ * a value that is no integer as {@code InvalidParameterValue}; everything else is reported
+ * together, in the order the model lists the members.
+ *
+ * <p>Three things here are readings rather than published behaviour, and the docs say so. The
+ * model publishes no enum for {@code SigningAlgorithm}, only the fixed length, so a five
+ * character value that is neither {@code RS256} nor {@code ES384} is answered with the enum
+ * violation this package renders for a value outside a documented set. The global endpoint is
+ * refused because the Reference says "The GetWebIdentityToken API is not available on the STS
+ * Global endpoint" without giving the refusal, so it borrows the wording AWS publishes for
+ * {@code AssumeRoot}, and a request to a local host names no such endpoint and is not
+ * refused. {@code JWTPayloadSizeExceededException} is modelled and nothing published says what
+ * the maximum payload is, so no size is invented here to refuse.
+ *
+ * <p>A temporary credential with no live session behind it is refused as expired rather than
+ * read as a caller that cannot be identified. {@link IamEnforcementFilter} answers
+ * {@code ExpiredTokenException} for one and it never reaches here, but with enforcement off,
+ * or in the window between that check and this one, the session lookup comes back empty and
+ * the caller would fall to the account root ARN this file hands an unresolvable caller. A
+ * token is not a request: its subject is signed and outlives the call, so a session already
+ * gone does not get one that speaks for the account. An unknown long-term key keeps the
+ * stand-in, which is what {@code GetCallerIdentity} answers it.
+ */
+ private Response handleGetWebIdentityToken(MultivaluedMap<String, String> params) {
+ if (arrivedOnTheGlobalEndpoint()) {
+ return AwsQueryResponse.error("ValidationError", "The global endpoint is not supported"
+ + " for GetWebIdentityToken. You must send this request to a Regional AWS STS"
+ + " endpoint.", AwsNamespaces.STS, 400);
+ }
+ Response durationValidation =
+ validateDurationSeconds(params, MIN_TOKEN_SECONDS, MAX_TOKEN_SECONDS);
+ if (durationValidation != null) {
+ return durationValidation;
+ }
+ List<ListMember> audiences = listMembers(params, AUDIENCE_MEMBER);
+ Map<String, String> tagClaims = new LinkedHashMap<>();
+ List<String> violations = new ArrayList<>(audienceViolations(params, audiences));
+ violations.addAll(signingAlgorithmViolations(params.getFirst("SigningAlgorithm")));
+ violations.addAll(tagViolations(params, tagClaims));
+ if (!violations.isEmpty()) {
+ return AwsQueryResponse.error("ValidationError",
+ SmithyValidationErrors.message(violations), AwsNamespaces.STS, 400);
+ }
+
+ String accessKeyId = callerAccessKeyId();
+ Optional<Instant> sessionEnds = accessKeyId == null
+ ? Optional.empty()
+ : iamService.findSessionExpiration(accessKeyId);
+ if (sessionEnds.isEmpty() && IamService.isTemporaryAccessKey(accessKeyId)) {
+ return AwsQueryResponse.error("ExpiredTokenException",
+ IamEnforcementFilter.EXPIRED_TOKEN, AwsNamespaces.STS, 403);
+ }
+
+ Optional<OutboundWebIdentityFederation> federation =
+ iamService.findEnabledOutboundWebIdentityFederation();
+ if (federation.isEmpty()) {
+ return AwsQueryResponse.error("OutboundWebIdentityFederationDisabledException",
+ "The outbound web identity federation feature is not enabled for this account."
+ + " To use this feature, you must first enable it through the AWS"
+ + " Management Console or API.", AwsNamespaces.STS, 403);
+ }
+ Instant issuedAt = clock.instant();
+ Instant expiration = issuedAt.plusSeconds(
+ getIntParam(params, "DurationSeconds", DEFAULT_TOKEN_SECONDS));
+ if (sessionEnds.filter(expiration::isAfter).isPresent()) {
+ return AwsQueryResponse.error("SessionDurationEscalationException",
+ "The requested token duration would extend the session beyond its original"
+ + " expiration time. You cannot use this operation to extend the"
+ + " lifetime of a session beyond what was granted when the session was"
+ + " originally created.", AwsNamespaces.STS, 403);
+ }
+ String subject = iamService.resolveCallerArn(accessKeyId).orElseGet(() ->
+ regionResolver.buildGlobalArn("iam", regionResolver.getAccountId(), "root"));
+ String token = tokenIssuer.mint(
+ WebIdentityTokenIssuer.Algorithm.valueOf(params.getFirst("SigningAlgorithm")),
+ federation.get().getIssuerIdentifier(), subject,
+ audiences.stream().map(member -> value(params, member)).toList(),
+ new WebIdentityTokenIssuer.CustomClaims(regionResolver.getAccountId(),
+ regionResolver.getRegion(), tagClaims),
+ issuedAt, expiration);
+ LOG.debugv("Issued a web identity token for {0} expiring at {1}", subject, expiration);
+ String result = new XmlBuilder()
+ .elem("WebIdentityToken", token)
+ .elem("Expiration", isoDate(expiration))
+ .build();
+ return Response.ok(
+ AwsQueryResponse.envelope("GetWebIdentityToken", AwsNamespaces.STS, result)).build();
+ }
+
+ /**
+ * One member of a Query list: the prefix its parameters are named under, and the index the
+ * request numbered it with, read back as it was spelled rather than as the number it reads as.
+ */
+ private record ListMember(String prefix, String index) {
+ }
+
+ /**
+ * The members of a list, in the order their indexes read. The patterns capture the prefix
+ * because a member of a list of structures carries its fields under it, which
+ * {@link AwsQueryLists#memberKeys} does not match, and because the index a path names is the
+ * one the request sent. A member present with an empty value is still a member.
+ */
+ private static List<ListMember> listMembers(MultivaluedMap<String, String> params,
+ Pattern names) {
+ return params.keySet().stream()
+ .map(names::matcher)
+ .filter(Matcher::matches)
+ .map(matcher -> new ListMember(matcher.group(1), matcher.group(2)))
+ .distinct()
+ .sorted(Comparator.comparingInt(
+ member -> AwsQueryLists.memberIndex(member.prefix())))
+ .toList();
+ }
+
+ private static String value(MultivaluedMap<String, String> params, ListMember member) {
+ String value = params.getFirst(member.prefix());
+ return value == null ? "" : value;
+ }
+
+ /**
+ * {@code Audience} is required, so a list of no members is the required member reading as null:
+ * a Query list of none is how an absent one arrives, which is what makes its minimum of 1
+ * unreachable on its own.
+ */
+ private static List<String> audienceViolations(MultivaluedMap<String, String> params,
+ List<ListMember> audiences) {
+ if (audiences.isEmpty()) {
+ return List.of(SmithyValidationErrors.notNull("audience"));
+ }
+ List<String> violations = new ArrayList<>();
+ if (audiences.size() > MAX_TOKEN_AUDIENCES) {
+ violations.add("Value at 'audience' failed to satisfy constraint: Member must have"
+ + " length less than or equal to " + MAX_TOKEN_AUDIENCES);
+ }
+ for (ListMember audience : audiences) {
+ addIfPresent(violations, SmithyValidationErrors.lengthOutOfRange(
+ "audience." + audience.index() + ".member", value(params, audience), 1,
+ MAX_TOKEN_AUDIENCE_LENGTH));
+ }
+ return violations;
+ }
+
+ /**
+ * The model gives {@code jwtAlgorithmType} a fixed length of 5 and no enum, and the Reference
+ * names the two values that length is for, so the length is the declared constraint and the
+ * value set is read from the documentation.
+ */
+ private static List<String> signingAlgorithmViolations(String algorithm) {
+ if (algorithm == null) {
+ return List.of(SmithyValidationErrors.notNull("signingAlgorithm"));
+ }
+ String length = SmithyValidationErrors.lengthOutOfRange("signingAlgorithm", algorithm,
+ SIGNING_ALGORITHM_LENGTH, SIGNING_ALGORITHM_LENGTH);
+ if (length != null) {
+ return List.of(length);
+ }
+ if (!WebIdentityTokenIssuer.Algorithm.names().contains(algorithm)) {
+ return List.of(SmithyValidationErrors.notInEnum(algorithm, "signingAlgorithm",
+ WebIdentityTokenIssuer.Algorithm.names()));
+ }
+ return List.of();
+ }
+
+ /**
+ * Each tag is a {@code Tag}, which declares both its key and its value required, so a member
+ * sent with only one of them breaks the other. The claims a valid tag set contributes are
+ * collected here rather than read a second time, the last value winning for a key sent twice,
+ * which is how a Query map's duplicate key resolves elsewhere in this package.
+ */
+ private static List<String> tagViolations(MultivaluedMap<String, String> params,
+ Map<String, String> claims) {
+ List<ListMember> tags = listMembers(params, TAG_MEMBER);
+ if (tags.isEmpty()) {
+ return List.of();
+ }
+ List<String> violations = new ArrayList<>();
+ if (tags.size() > MAX_TOKEN_TAGS) {
+ violations.add("Value at 'tags' failed to satisfy constraint: Member must have length"
+ + " less than or equal to " + MAX_TOKEN_TAGS);
+ }
+ for (ListMember tag : tags) {
+ String path = "tags." + tag.index() + ".member.";
+ String key = params.getFirst(tag.prefix() + ".Key");
+ String value = params.getFirst(tag.prefix() + ".Value");
+ if (key == null) {
+ violations.add(SmithyValidationErrors.notNull(path + "key"));
+ } else {
+ addIfPresent(violations, SmithyValidationErrors.lengthOutOfRange(path + "key", key,
+ 1, MAX_TAG_KEY_LENGTH));
+ addIfPresent(violations, patternViolation(path + "key", key, false));
+ }
+ if (value == null) {
+ violations.add(SmithyValidationErrors.notNull(path + "value"));
+ } else {
+ addIfPresent(violations, SmithyValidationErrors.lengthOutOfRange(path + "value",
+ value, 0, MAX_TAG_VALUE_LENGTH));
+ addIfPresent(violations, patternViolation(path + "value", value, true));
+ }
+ if (key != null && value != null) {
+ claims.put(key, value);
+ }
+ }
+ return violations;
+ }
+
+ /** {@code tagValueType}'s pattern allows an empty value where {@code tagKeyType}'s does not. */
+ private static String patternViolation(String path, String value, boolean emptyAllowed) {
+ if (emptyAllowed && value.isEmpty()) {
+ return null;
+ }
+ if (TAG_PATTERN.matcher(value).matches()) {
+ return null;
+ }
+ return "Value '" + value + "' at '" + path + "' failed to satisfy constraint: Member must"
+ + " satisfy regular expression pattern: " + TAG_PATTERN.pattern();
+ }
+
+ private static void addIfPresent(List<String> violations, String violation) {
+ if (violation != null) {
+ violations.add(violation);
+ }
+ }
+
private String credentialsXml(String accessKeyId, String secretKey, String sessionToken, Instant expiration) {
return new XmlBuilder()
.start("Credentials")
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuer.java b/src/main/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuer.java
new file mode 100644
index 0000000000..5a9833f2d9
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuer.java
@@ -0,0 +1,187 @@
+package io.github.hectorvent.floci.services.iam;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.CompactJws;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.iam.model.WebIdentityTokenKey;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.security.GeneralSecurityException;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.time.Instant;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Mints the signed JWT {@code GetWebIdentityToken} answers with, and owns the signing material
+ * behind it. The issuer URL is IAM's: outbound web identity federation mints one per account, and
+ * the token names it as {@code iss} so a relying party that pinned that issuer can verify against
+ * the keys it publishes.
+ *
+ * <p>The claim layout is the one the IAM User Guide publishes: the standard OIDC claims at the
+ * top level, and the AWS identity claims and the request's tags nested under the
+ * {@code https://sts.amazonaws.com/} namespace, where the guide's sample token carries
+ * {@code aws_account}, {@code source_region} and the tags under {@code request_tags}. "Please note
+ * that all these claims may not be present in a token at the same time", so the organization,
+ * principal tag and session context claims the guide also lists are left out rather than
+ * invented, and {@code request_tags} is absent from a token whose request named none.
+ *
+ * <p>The nesting is also what keeps a tag off a claim STS sets: a tag named {@code exp} or
+ * {@code sub} is a key under {@code request_tags}, so no request can lengthen its own token's life
+ * or speak for another identity by naming a tag after the claim that says so.
+ */
+@ApplicationScoped
+public class WebIdentityTokenIssuer {
+
+ private static final Logger LOG = Logger.getLogger(WebIdentityTokenIssuer.class);
+
+ private static final int RSA_KEY_SIZE = 2048;
+ /** P-384, the curve {@code ES384} names, as the JDK spells it. */
+ private static final String P384_CURVE = "secp384r1";
+ /** The namespace the guide nests the identity claims and the request's tags under. */
+ private static final String CLAIM_NAMESPACE = "https://sts.amazonaws.com/"; // partition-literal: the claim namespace the IAM User Guide publishes, with no source for another partition's spelling (P9)
+
+ private final StorageBackend<String, WebIdentityTokenKey> keyStore;
+ private final ObjectMapper objectMapper;
+
+ @Inject
+ public WebIdentityTokenIssuer(StorageFactory storageFactory, ObjectMapper objectMapper) {
+ this(storageFactory.create("iam", "sts-web-identity-token-keys.json",
+ new TypeReference<Map<String, WebIdentityTokenKey>>() {
+ }), objectMapper);
+ }
+
+ WebIdentityTokenIssuer(StorageBackend<String, WebIdentityTokenKey> keyStore,
+ ObjectMapper objectMapper) {
+ this.keyStore = keyStore;
+ this.objectMapper = objectMapper;
+ }
+
+ /**
+ * The two algorithms the operation publishes, in the order the API Reference names them:
+ * "Valid values are RS256 (RSA with SHA-256) and ES384 (ECDSA using P-384 curve with
+ * SHA-384)". Each carries the JCA names behind it, the signature one in the {@code P1363}
+ * variant for ECDSA, since JWS defines that signature as the raw {@code R || S} pair.
+ */
+ public enum Algorithm {
+
+ RS256("RSA", "SHA256withRSA"),
+ ES384("EC", "SHA384withECDSAinP1363Format");
+
+ private final String keyAlgorithm;
+ private final String signatureAlgorithm;
+
+ Algorithm(String keyAlgorithm, String signatureAlgorithm) {
+ this.keyAlgorithm = keyAlgorithm;
+ this.signatureAlgorithm = signatureAlgorithm;
+ }
+
+ /** The names the Reference lists, in the order a violation reports them in. */
+ public static List<String> names() {
+ return List.of(RS256.name(), ES384.name());
+ }
+ }
+
+ /**
+ * The claims the guide nests under the namespace: the account the token was asked for, the
+ * region it was asked from, and the request's tags, which the guide carries under
+ * {@code request_tags}.
+ */
+ public record CustomClaims(String account, String sourceRegion,
+ Map<String, String> requestTags) {
+ }
+
+ /**
+ * The token for one request: the standard claims, the custom claims under AWS's own namespace,
+ * and the {@code kid} of the account's key for {@code algorithm}, minted on first use.
+ */
+ public String mint(Algorithm algorithm, String issuer, String subject, List<String> audiences,
+ CustomClaims custom, Instant issuedAt, Instant expiresAt) {
+ WebIdentityTokenKey key = ensureKey(algorithm);
+ ObjectNode header = objectMapper.createObjectNode();
+ header.put("alg", algorithm.name());
+ header.put("typ", "JWT");
+ header.put("kid", key.getKeyId());
+ ObjectNode claims = claims(issuer, subject, audiences, custom, issuedAt, expiresAt);
+ return CompactJws.sign(writeJson(header), writeJson(claims),
+ privateKey(key, algorithm), algorithm.signatureAlgorithm);
+ }
+
+ private ObjectNode claims(String issuer, String subject, List<String> audiences,
+ CustomClaims custom, Instant issuedAt, Instant expiresAt) {
+ ObjectNode claims = objectMapper.createObjectNode();
+ claims.put("iss", issuer);
+ ArrayNode audience = claims.putArray("aud");
+ audiences.forEach(audience::add);
+ claims.put("sub", subject);
+ claims.put("iat", issuedAt.getEpochSecond());
+ claims.put("exp", expiresAt.getEpochSecond());
+ claims.put("jti", UUID.randomUUID().toString());
+ ObjectNode identity = claims.putObject(CLAIM_NAMESPACE);
+ identity.put("aws_account", custom.account());
+ identity.put("source_region", custom.sourceRegion());
+ if (!custom.requestTags().isEmpty()) {
+ ObjectNode requestTags = identity.putObject("request_tags");
+ custom.requestTags().forEach(requestTags::put);
+ }
+ return claims;
+ }
+
+ private synchronized WebIdentityTokenKey ensureKey(Algorithm algorithm) {
+ return keyStore.get(algorithm.name()).orElseGet(() -> generateKey(algorithm));
+ }
+
+ private WebIdentityTokenKey generateKey(Algorithm algorithm) {
+ try {
+ KeyPairGenerator generator = KeyPairGenerator.getInstance(algorithm.keyAlgorithm);
+ switch (algorithm) {
+ case RS256 -> generator.initialize(RSA_KEY_SIZE);
+ case ES384 -> generator.initialize(new ECGenParameterSpec(P384_CURVE));
+ }
+ KeyPair pair = generator.generateKeyPair();
+ WebIdentityTokenKey key = new WebIdentityTokenKey();
+ key.setKeyId(UUID.randomUUID().toString().replace("-", ""));
+ key.setPublicKey(Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));
+ key.setPrivateKey(Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));
+ keyStore.put(algorithm.name(), key);
+ LOG.debugv("Generated the account's {0} web identity token signing key", algorithm);
+ return key;
+ } catch (GeneralSecurityException e) {
+ throw new IllegalStateException(
+ "Failed to generate a " + algorithm + " web identity token signing key", e);
+ }
+ }
+
+ private static PrivateKey privateKey(WebIdentityTokenKey key, Algorithm algorithm) {
+ try {
+ PKCS8EncodedKeySpec spec =
+ new PKCS8EncodedKeySpec(Base64.getDecoder().decode(key.getPrivateKey()));
+ return KeyFactory.getInstance(algorithm.keyAlgorithm).generatePrivate(spec);
+ } catch (GeneralSecurityException | IllegalArgumentException e) {
+ throw new IllegalStateException(
+ "Failed to load the " + algorithm + " web identity token signing key", e);
+ }
+ }
+
+ private byte[] writeJson(ObjectNode node) {
+ try {
+ return objectMapper.writeValueAsBytes(node);
+ } catch (JsonProcessingException e) {
+ throw new IllegalStateException("Failed to serialize web identity token claims", e);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/WebIdentityTokenKey.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/WebIdentityTokenKey.java
new file mode 100644
index 0000000000..535943608d
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/WebIdentityTokenKey.java
@@ -0,0 +1,32 @@
+package io.github.hectorvent.floci.services.iam.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+/**
+ * The signing material behind one of the account's web identity token algorithms: the key id the
+ * token's {@code kid} header names, and the keypair itself, the public half X.509 encoded and the
+ * private half PKCS#8, both base64.
+ *
+ * <p>One of these exists per account and per signing algorithm, minted the first time a token asks
+ * for that algorithm. It is stored rather than held in memory because a relying party verifies a
+ * token against the published key, so a restart that minted a new one would invalidate every token
+ * already handed out.
+ */
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class WebIdentityTokenKey {
+
+ private String keyId;
+ private String publicKey;
+ private String privateKey;
+
+ public WebIdentityTokenKey() {}
+
+ public String getKeyId() { return keyId; }
+ public void setKeyId(String keyId) { this.keyId = keyId; }
+ public String getPublicKey() { return publicKey; }
+ public void setPublicKey(String publicKey) { this.publicKey = publicKey; }
+ public String getPrivateKey() { return privateKey; }
+ public void setPrivateKey(String privateKey) { this.privateKey = privateKey; }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
index 5113348e95..5207447553 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.core.common.WebIdentityToken;
import io.github.hectorvent.floci.core.common.WebIdentityTokenVerifier;
import io.github.hectorvent.floci.services.iam.model.DelegationRequest;
import io.github.hectorvent.floci.services.iam.model.IamRole;
+import io.github.hectorvent.floci.services.iam.model.OutboundWebIdentityFederation;
import io.github.hectorvent.floci.testing.PartitionMatrix;
import io.github.hectorvent.floci.testing.PartitionMatrix.PartitionCase;
import jakarta.ws.rs.core.HttpHeaders;
@@ -36,6 +37,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
@@ -88,6 +90,13 @@ class StsQueryHandlerTest {
private static StsQueryHandler newHandler(IamService iamService, RegionResolver regionResolver,
Clock clock, DelegationRequestService delegation) {
+ return newHandler(iamService, regionResolver, clock, delegation,
+ mock(WebIdentityTokenIssuer.class));
+ }
+
+ private static StsQueryHandler newHandler(IamService iamService, RegionResolver regionResolver,
+ Clock clock, DelegationRequestService delegation,
+ WebIdentityTokenIssuer tokenIssuer) {
EmulatorConfig config = mock(EmulatorConfig.class);
EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);
EmulatorConfig.IamServiceConfig iam = mock(EmulatorConfig.IamServiceConfig.class);
@@ -108,6 +117,7 @@ class StsQueryHandlerTest {
mock(SAMLTrustPolicyEvaluator.class),
delegation,
mock(CentralRootAccess.class),
+ tokenIssuer,
clock);
}
@@ -143,6 +153,91 @@ class StsQueryHandlerTest {
}
}
+ /** The account's federation state with the feature on, which the operation reads the issuer from. */
+ private static OutboundWebIdentityFederation enabledFederation() {
+ OutboundWebIdentityFederation federation = new OutboundWebIdentityFederation();
+ federation.setEnabled(true);
+ federation.setIssuerIdentifier("https://sts.us-east-1.amazonaws.com/000000000000");
+ return federation;
+ }
+
+ /**
+ * A caller on temporary credentials "cannot use this operation to extend the lifetime of a
+ * session beyond what was granted when the session was originally created", so the ceiling on
+ * a web identity token is the session's own expiration. The boundary is that instant itself: a
+ * token ending exactly with the session is issued, and one ending a second later is not, which
+ * is why the clock is fixed here rather than read. A long-term caller has no session to
+ * escalate, so only the duration's own 3600 holds it.
+ */
+ @ParameterizedTest
+ @CsvSource({"ASIASESSION, 299, 200", "ASIASESSION, 300, 200", "ASIASESSION, 301, 403",
+ "ASIASESSION, 3600, 403", "AKIALONGTERM, 3600, 200"})
+ void aWebIdentityTokenCannotOutliveTheCallersSession(String accessKeyId, String duration,
+ int expectedStatus) {
+ Instant now = Instant.parse("2026-01-01T00:00:00Z");
+ IamService iamService = mock(IamService.class);
+ when(iamService.findEnabledOutboundWebIdentityFederation())
+ .thenReturn(Optional.of(enabledFederation()));
+ when(iamService.findSessionExpiration("ASIASESSION"))
+ .thenReturn(Optional.of(now.plusSeconds(300)));
+ WebIdentityTokenIssuer tokenIssuer = mock(WebIdentityTokenIssuer.class);
+ when(tokenIssuer.mint(any(), anyString(), anyString(), anyList(), any(), any(), any()))
+ .thenReturn("header.claims.signature");
+ StsQueryHandler handler = newHandler(iamService, new RegionResolver(REGION, "000000000000"),
+ Clock.fixed(now, ZoneOffset.UTC), mock(DelegationRequestService.class),
+ tokenIssuer);
+ setCaller(handler, accessKeyId, "-");
+
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("Audience.member.1", "app");
+ params.putSingle("SigningAlgorithm", "RS256");
+ params.putSingle("DurationSeconds", duration);
+ Response response = handler.handle("GetWebIdentityToken", params);
+
+ String body = (String) response.getEntity();
+ assertEquals(expectedStatus, response.getStatus(), body);
+ if (expectedStatus == 403) {
+ assertTrue(body.contains("<Code>SessionDurationEscalationException</Code>"), body);
+ assertTrue(body.contains("You cannot use this operation to extend the lifetime of a"
+ + " session beyond what was granted when the session was originally created."),
+ body);
+ verifyNoInteractions(tokenIssuer);
+ } else {
+ verify(tokenIssuer).mint(any(), anyString(), anyString(), anyList(), any(), any(),
+ any());
+ }
+ }
+
+ /**
+ * A temporary credential the session store no longer knows is refused as expired rather than
+ * minted for. The lookup comes back empty for a session that has gone, which would otherwise
+ * fall through to the account root ARN this file hands a caller it cannot resolve, and a
+ * token's subject is signed and outlives the request that asked for it.
+ */
+ @Test
+ void aTemporaryCredentialWithNoLiveSessionIsRefusedRatherThanSignedAsRoot() {
+ IamService iamService = mock(IamService.class);
+ when(iamService.findEnabledOutboundWebIdentityFederation())
+ .thenReturn(Optional.of(enabledFederation()));
+ WebIdentityTokenIssuer tokenIssuer = mock(WebIdentityTokenIssuer.class);
+ StsQueryHandler handler = newHandler(iamService, new RegionResolver(REGION, "000000000000"),
+ Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneOffset.UTC),
+ mock(DelegationRequestService.class), tokenIssuer);
+ setCaller(handler, "ASIAGONE", "-");
+
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("Audience.member.1", "app");
+ params.putSingle("SigningAlgorithm", "RS256");
+ Response response = handler.handle("GetWebIdentityToken", params);
+
+ String body = (String) response.getEntity();
+ assertEquals(403, response.getStatus(), body);
+ assertTrue(body.contains("<Code>ExpiredTokenException</Code>"), body);
+ assertTrue(body.contains("The security token included in the request has expired."), body);
+ assertFalse(body.contains(":root"), body);
+ verifyNoInteractions(tokenIssuer);
+ }
+
private static void setCaller(StsQueryHandler handler, String headerKey, String queryKey) {
handler.headers = mock(HttpHeaders.class);
if (!"-".equals(headerKey)) {
@@ -662,7 +757,8 @@ class StsQueryHandlerTest {
StsQueryHandler handler = new StsQueryHandler(iamService, mock(AccountResolver.class),
new RegionResolver(REGION, "000000000000"), config, mock(AssumeRolePolicyEvaluator.class),
trust, verifier, keys, mock(SAMLProviderService.class), mock(SAMLTrustPolicyEvaluator.class),
- mock(DelegationRequestService.class), mock(CentralRootAccess.class));
+ mock(DelegationRequestService.class), mock(CentralRootAccess.class),
+ mock(WebIdentityTokenIssuer.class));
MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
params.putSingle("RoleArn", requestedRoleArn);
params.putSingle("RoleSessionName", "app");
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIntegrationTest.java
new file mode 100644
index 0000000000..0b8f57ff47
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIntegrationTest.java
@@ -0,0 +1,353 @@
+package io.github.hectorvent.floci.services.iam;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.ExtractableResponse;
+import io.restassured.response.Response;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.Test;
+
+import java.time.Instant;
+import java.util.Base64;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.matchesPattern;
+import static org.hamcrest.Matchers.not;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * {@code GetWebIdentityToken} over the wire: the signed JWT it answers with, the switch it reads,
+ * and the constraints it is held to.
+ *
+ * <p>The token is checked here by decoding it rather than by verifying its signature, no endpoint
+ * publishing the verification key yet, that being the other half of the feature. What is checked
+ * instead is the shape a verifier depends on, including the one detail an ECDSA JWS is easy to get
+ * wrong: the signature is the raw {@code R || S} pair, 96 bytes for P-384, rather than the
+ * variable-length DER sequence the JDK's default ECDSA signer returns. That the signature verifies
+ * at all, against the key the issuer stored and over the claims it was made for, is
+ * {@link WebIdentityTokenIssuerTest}, which reaches the key through the store.
+ *
+ * <p>The feature switch is account-level and shared, so each test sets the state it needs first.
+ */
+@QuarkusTest
+class WebIdentityTokenIntegrationTest {
+
+ private static final String IAM_AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20261025/us-east-1/iam/aws4_request";
+ private static final String STS_AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20261025/us-east-1/sts/aws4_request";
+
+ private static final String TOKEN =
+ "GetWebIdentityTokenResponse.GetWebIdentityTokenResult.WebIdentityToken";
+ private static final String EXPIRATION =
+ "GetWebIdentityTokenResponse.GetWebIdentityTokenResult.Expiration";
+ /** A violation is read off the message rather than the body, which escapes its quotes. */
+ private static final String CODE = "ErrorResponse.Error.Code";
+ private static final String MESSAGE = "ErrorResponse.Error.Message";
+ private static final String ISSUER = "GetOutboundWebIdentityFederationInfoResponse"
+ + ".GetOutboundWebIdentityFederationInfoResult.IssuerIdentifier";
+ /** The namespace the IAM User Guide nests the identity claims and the request's tags under. */
+ private static final String CLAIM_NAMESPACE = "https://sts.amazonaws.com/";
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ private static RequestSpecification iam(String action) {
+ return given().header("Authorization", IAM_AUTH).formParam("Action", action);
+ }
+
+ private static RequestSpecification sts(String action) {
+ return given().header("Authorization", STS_AUTH).formParam("Action", action);
+ }
+
+ /** One audience and RS256, which is the shape the Reference's own sample request sends. */
+ private static RequestSpecification token(String algorithm) {
+ return sts("GetWebIdentityToken")
+ .formParam("Audience.member.1", "app")
+ .formParam("SigningAlgorithm", algorithm);
+ }
+
+ /** The same request, signed as the session {@code GetSessionToken} handed out. */
+ private static RequestSpecification session(String accessKeyId) {
+ return given()
+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + accessKeyId
+ + "/20261025/us-east-1/sts/aws4_request")
+ .formParam("Action", "GetWebIdentityToken")
+ .formParam("Audience.member.1", "app")
+ .formParam("SigningAlgorithm", "RS256");
+ }
+
+ /** Enables the feature if it is off, and answers with the account's issuer either way. */
+ private static String enabledIssuer() {
+ iam("EnableOutboundWebIdentityFederation").when().post("/");
+ return iam("GetOutboundWebIdentityFederationInfo")
+ .when().post("/").then().statusCode(200).extract().path(ISSUER);
+ }
+
+ private static void disableFederation() {
+ iam("DisableOutboundWebIdentityFederation").when().post("/");
+ }
+
+ private static JsonNode part(String jwt, int index) throws Exception {
+ return MAPPER.readTree(Base64.getUrlDecoder().decode(jwt.split("\\.", -1)[index]));
+ }
+
+ private static byte[] signature(String jwt) {
+ return Base64.getUrlDecoder().decode(jwt.split("\\.", -1)[2]);
+ }
+
+ /**
+ * "The token contains standard JWT claims such as subject, audience, expiration time", the
+ * audience being the one the request named, and the issuer the one IAM minted for the account.
+ * The default duration is 300 seconds, and {@code Expiration} names the same instant as
+ * {@code exp}. Beside them sit the identity claims the guide nests under its own namespace,
+ * the account the token was asked for and the region it was asked from, and no
+ * {@code request_tags} where the request named no tags.
+ */
+ @Test
+ void aTokenCarriesTheStandardClaimsAndTheAccountsIssuer() throws Exception {
+ String issuer = enabledIssuer();
+
+ String jwt = token("RS256").when().post("/").then().statusCode(200)
+ .body(EXPIRATION, matchesPattern("\\d{4}-\\d{2}-\\d{2}T.*Z"))
+ .extract().path(TOKEN);
+
+ JsonNode header = part(jwt, 0);
+ assertEquals("RS256", header.path("alg").asText());
+ assertEquals("JWT", header.path("typ").asText());
+ assertTrue(header.path("kid").asText().matches("[0-9a-f]{32}"), header.toString());
+
+ JsonNode claims = part(jwt, 1);
+ assertEquals(issuer, claims.path("iss").asText());
+ assertEquals(1, claims.path("aud").size(), claims.toString());
+ assertEquals("app", claims.path("aud").get(0).asText());
+ assertTrue(claims.path("sub").asText().matches("arn:aws[a-z-]*:iam::\\d{12}:.+"),
+ claims.toString());
+ assertEquals(300, claims.path("exp").asLong() - claims.path("iat").asLong());
+ assertNotNull(claims.path("jti").asText());
+ assertEquals(256, signature(jwt).length, "RS256 signs with the 2048-bit account key");
+
+ JsonNode identity = claims.path(CLAIM_NAMESPACE);
+ assertTrue(identity.path("aws_account").asText().matches("\\d{12}"), claims.toString());
+ assertEquals("us-east-1", identity.path("source_region").asText(), claims.toString());
+ assertTrue(identity.path("request_tags").isMissingNode(),
+ "a request that named no tags carries no request_tags claim");
+ }
+
+ /**
+ * {@code ES384} is "ECDSA using P-384 curve with SHA-384", and JWS defines that signature as
+ * the raw {@code R || S} pair: two 48-byte halves for P-384. A DER sequence would be close to
+ * this length and would verify nowhere.
+ */
+ @Test
+ void anEs384TokenSignsWithTheRawPairJwsDefines() throws Exception {
+ enabledIssuer();
+
+ String jwt = token("ES384").when().post("/").then().statusCode(200).extract().path(TOKEN);
+
+ assertEquals("ES384", part(jwt, 0).path("alg").asText());
+ assertEquals(96, signature(jwt).length, "ES384 is R || S over P-384, not DER");
+ }
+
+ /**
+ * Request tags "appear under the request_tags field in the token", which the guide nests under
+ * the same namespace as the identity claims. That nesting is also what keeps a tag named after
+ * a claim STS sets out of it: such a tag is a key under {@code request_tags}, so it cannot
+ * lengthen the token's own life.
+ */
+ @Test
+ void tagsBecomeRequestTagsUnderTheNamespaceRatherThanClaimsOfTheirOwn() throws Exception {
+ enabledIssuer();
+
+ String jwt = token("RS256")
+ .formParam("Tags.member.1.Key", "Team")
+ .formParam("Tags.member.1.Value", "platform")
+ .formParam("Tags.member.2.Key", "exp")
+ .formParam("Tags.member.2.Value", "99999999999")
+ .when().post("/").then().statusCode(200).extract().path(TOKEN);
+
+ JsonNode claims = part(jwt, 1);
+ JsonNode requestTags = claims.path(CLAIM_NAMESPACE).path("request_tags");
+ assertEquals("platform", requestTags.path("Team").asText(), claims.toString());
+ assertEquals("99999999999", requestTags.path("exp").asText(),
+ "a tag named after a claim is a request tag, not that claim");
+ assertTrue(claims.path("Team").isMissingNode(), "a tag is not a claim of its own");
+ assertEquals(300, claims.path("exp").asLong() - claims.path("iat").asLong(),
+ "the request's own exp tag does not become the expiry");
+ }
+
+ /**
+ * The duration is 60 to 3600, and {@code Expiration} is "determined by adding the
+ * DurationSeconds value to the time the token was issued".
+ */
+ @Test
+ void theDurationIsHeldToItsRangeAndSetsTheExpiry() throws Exception {
+ enabledIssuer();
+
+ ExtractableResponse<Response> issued = token("RS256").formParam("DurationSeconds", "3600")
+ .when().post("/").then().statusCode(200).extract();
+ JsonNode claims = part(issued.path(TOKEN), 1);
+ assertEquals(3600, claims.path("exp").asLong() - claims.path("iat").asLong());
+ assertEquals(claims.path("exp").asLong(),
+ Instant.parse(issued.path(EXPIRATION)).getEpochSecond(),
+ "Expiration names the instant the exp claim does");
+
+ token("RS256").formParam("DurationSeconds", "59").when().post("/").then().statusCode(400)
+ .body(containsString("ValidationError"))
+ .body(containsString("Member must have value greater than or equal to 60"));
+ token("RS256").formParam("DurationSeconds", "3601").when().post("/").then().statusCode(400)
+ .body(containsString("Member must have value less than or equal to 3600"));
+ }
+
+ /** The feature's own refusal, which is not IAM's {@code FeatureDisabled} 404. */
+ @Test
+ void theSwitchBeingOffIsTheOperationsOwnRefusal() {
+ disableFederation();
+
+ token("RS256").when().post("/").then().statusCode(403)
+ .body(CODE, equalTo("OutboundWebIdentityFederationDisabledException"))
+ .body(MESSAGE, containsString("The outbound web identity federation feature is not"
+ + " enabled for this account."))
+ .body(not(containsString("FeatureDisabled")));
+
+ enabledIssuer();
+ }
+
+ /**
+ * The validation layer runs ahead of the operation, so a request that breaks a declared
+ * constraint is the 400 even where the feature the operation reads is off.
+ */
+ @Test
+ void theDeclaredConstraintsAreReadAheadOfTheSwitch() {
+ disableFederation();
+
+ sts("GetWebIdentityToken").formParam("SigningAlgorithm", "RS256")
+ .when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, equalTo("1 validation error detected: Value null at 'audience' failed"
+ + " to satisfy constraint: Member must not be null"))
+ .body(not(containsString("OutboundWebIdentityFederationDisabled")));
+
+ enabledIssuer();
+ }
+
+ /**
+ * Both required members are reported together when both are absent, and a member sent empty is
+ * a member that is present, so it breaks the minimum length of 1 rather than reading as absent.
+ */
+ @Test
+ void theRequiredMembersAndTheirBoundsAreReportedTogether() {
+ enabledIssuer();
+
+ sts("GetWebIdentityToken").when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo("2 validation errors detected: Value null at 'audience' failed"
+ + " to satisfy constraint: Member must not be null; Value null at"
+ + " 'signingAlgorithm' failed to satisfy constraint: Member must not be"
+ + " null"));
+
+ sts("GetWebIdentityToken")
+ .formParam("Audience.member.1", "")
+ .formParam("SigningAlgorithm", "RS256")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value '' at 'audience.1.member' failed to satisfy"
+ + " constraint: Member must have length greater than or equal to 1"));
+
+ RequestSpecification eleven = sts("GetWebIdentityToken")
+ .formParam("SigningAlgorithm", "RS256");
+ for (int audience = 1; audience <= 11; audience++) {
+ eleven.formParam("Audience.member." + audience, "app" + audience);
+ }
+ eleven.when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value at 'audience' failed to satisfy constraint:"
+ + " Member must have length less than or equal to 10"));
+ }
+
+ /**
+ * {@code jwtAlgorithmType} publishes a fixed length of 5 and no enum, so the length is the
+ * declared constraint and the two values the Reference names are read from it.
+ */
+ @Test
+ void aSigningAlgorithmIsHeldToItsLengthAndThenToTheTwoValues() {
+ enabledIssuer();
+
+ token("RS25").when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value 'RS25' at 'signingAlgorithm' failed to satisfy"
+ + " constraint: Member must have length greater than or equal to 5"));
+
+ token("HS256").when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value 'HS256' at 'signingAlgorithm' failed to satisfy"
+ + " constraint: Member must satisfy enum value set: [RS256, ES384]"));
+ }
+
+ /**
+ * The session ceiling against a real session rather than a stubbed one: {@code GetSessionToken}
+ * hands out credentials that expire, and a token asked for past that instant is refused.
+ * {@code StsQueryHandlerTest} holds the boundary itself on a fixed clock; what this adds is
+ * that the expiration is found through the session the caller is actually on.
+ */
+ @Test
+ void aTokenIsRefusedWhereItWouldOutliveTheCallersOwnSession() throws Exception {
+ enabledIssuer();
+ String sessionKey = sts("GetSessionToken").formParam("DurationSeconds", "900")
+ .when().post("/").then().statusCode(200)
+ .extract().path("GetSessionTokenResponse.GetSessionTokenResult.Credentials.AccessKeyId");
+
+ session(sessionKey).formParam("DurationSeconds", "3600")
+ .when().post("/").then().statusCode(403)
+ .body(CODE, equalTo("SessionDurationEscalationException"))
+ .body(MESSAGE, containsString("You cannot use this operation to extend the lifetime"
+ + " of a session beyond what was granted when the session was originally"
+ + " created."));
+
+ String jwt = session(sessionKey).formParam("DurationSeconds", "60")
+ .when().post("/").then().statusCode(200).extract().path(TOKEN);
+ JsonNode claims = part(jwt, 1);
+ assertEquals(60, claims.path("exp").asLong() - claims.path("iat").asLong(),
+ "a token inside the session is issued for what it asked for");
+ }
+
+ /**
+ * The same refusal over the wire for a session key nothing issued, which reaches the operation
+ * because enforcement is off here: no token is minted, and none names the account root.
+ */
+ @Test
+ void aSessionKeyWithNoSessionBehindItIsRefusedAsExpired() {
+ enabledIssuer();
+
+ session("ASIANOSUCHSESSION001").when().post("/").then().statusCode(403)
+ .body(CODE, equalTo("ExpiredTokenException"))
+ .body(MESSAGE, equalTo("The security token included in the request has expired."))
+ .body(not(containsString(":root")));
+ }
+
+ /** A {@code Tag} declares its key and its value required, and each carries its own shape. */
+ @Test
+ void aTagIsHeldToItsOwnMembers() {
+ enabledIssuer();
+
+ token("RS256").formParam("Tags.member.1.Key", "Team")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value null at 'tags.1.member.value' failed to satisfy"
+ + " constraint: Member must not be null"));
+
+ token("RS256")
+ .formParam("Tags.member.1.Key", "Team?")
+ .formParam("Tags.member.1.Value", "platform")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("at 'tags.1.member.key' failed to satisfy constraint:"
+ + " Member must satisfy regular expression pattern"));
+
+ RequestSpecification fiftyOne = token("RS256");
+ for (int tag = 1; tag <= 51; tag++) {
+ fiftyOne.formParam("Tags.member." + tag + ".Key", "Key" + tag)
+ .formParam("Tags.member." + tag + ".Value", "value" + tag);
+ }
+ fiftyOne.when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("Value at 'tags' failed to satisfy constraint: Member"
+ + " must have length less than or equal to 50"));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuerTest.java
new file mode 100644
index 0000000000..acaee5cb90
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/WebIdentityTokenIssuerTest.java
@@ -0,0 +1,145 @@
+package io.github.hectorvent.floci.services.iam;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.services.iam.model.WebIdentityTokenKey;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+import java.nio.charset.StandardCharsets;
+import java.security.KeyFactory;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.spec.X509EncodedKeySpec;
+import java.time.Instant;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * What the wire test cannot check: that a token verifies against the key the issuer stored. Nothing
+ * publishes that key yet, that being the other half of the feature, so this reaches it through the
+ * store the issuer is built with.
+ *
+ * <p>The JCA names are spelled out here rather than read off
+ * {@link WebIdentityTokenIssuer.Algorithm}, which is the point of the exercise: a signature that
+ * stopped being the raw {@code R || S} pair JWS defines would fail this verifier rather than
+ * follow the change into it.
+ */
+class WebIdentityTokenIssuerTest {
+
+ private static final String ISSUER = "https://sts.us-east-1.amazonaws.com/000000000000";
+ private static final String SUBJECT = "arn:aws:iam::000000000000:user/token-holder";
+ private static final Instant ISSUED_AT = Instant.parse("2026-01-01T00:00:00Z");
+ private static final WebIdentityTokenIssuer.CustomClaims CUSTOM_CLAIMS =
+ new WebIdentityTokenIssuer.CustomClaims("000000000000", "us-east-1", Map.of());
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ private StorageBackend<String, WebIdentityTokenKey> keyStore;
+ private WebIdentityTokenIssuer issuer;
+
+ @BeforeEach
+ void setUp() {
+ keyStore = new InMemoryStorage<>();
+ issuer = new WebIdentityTokenIssuer(keyStore, MAPPER);
+ }
+
+ private String mint(WebIdentityTokenIssuer.Algorithm algorithm, long seconds) {
+ return issuer.mint(algorithm, ISSUER, SUBJECT, List.of("app"), CUSTOM_CLAIMS,
+ ISSUED_AT, ISSUED_AT.plusSeconds(seconds));
+ }
+
+ private static String segment(String jwt, int index) {
+ return jwt.split("\\.", -1)[index];
+ }
+
+ private static String signingInput(String jwt) {
+ return jwt.substring(0, jwt.lastIndexOf('.'));
+ }
+
+ private static byte[] signature(String jwt) {
+ return Base64.getUrlDecoder().decode(segment(jwt, 2));
+ }
+
+ private static String keyId(String jwt) throws Exception {
+ return MAPPER.readTree(Base64.getUrlDecoder().decode(segment(jwt, 0)))
+ .path("kid").asText();
+ }
+
+ private static String keyAlgorithm(WebIdentityTokenIssuer.Algorithm algorithm) {
+ return algorithm == WebIdentityTokenIssuer.Algorithm.RS256 ? "RSA" : "EC";
+ }
+
+ private static String signatureAlgorithm(WebIdentityTokenIssuer.Algorithm algorithm) {
+ return algorithm == WebIdentityTokenIssuer.Algorithm.RS256
+ ? "SHA256withRSA"
+ : "SHA384withECDSAinP1363Format";
+ }
+
+ /** Verifies a signature over the bytes given, against the stored public half of the key. */
+ private boolean verifies(WebIdentityTokenIssuer.Algorithm algorithm, String signingInput,
+ byte[] signature) throws Exception {
+ WebIdentityTokenKey key = keyStore.get(algorithm.name()).orElseThrow();
+ PublicKey publicKey = KeyFactory.getInstance(keyAlgorithm(algorithm)).generatePublic(
+ new X509EncodedKeySpec(Base64.getDecoder().decode(key.getPublicKey())));
+ Signature verifier = Signature.getInstance(signatureAlgorithm(algorithm));
+ verifier.initVerify(publicKey);
+ verifier.update(signingInput.getBytes(StandardCharsets.US_ASCII));
+ return verifier.verify(signature);
+ }
+
+ /** The token is signed over its own header and claims by the key stored for its algorithm. */
+ @ParameterizedTest
+ @EnumSource(WebIdentityTokenIssuer.Algorithm.class)
+ void aTokenVerifiesAgainstTheKeyTheIssuerStored(WebIdentityTokenIssuer.Algorithm algorithm)
+ throws Exception {
+ String jwt = mint(algorithm, 300);
+
+ assertTrue(verifies(algorithm, signingInput(jwt), signature(jwt)),
+ algorithm + " must verify against the key the issuer stored");
+ }
+
+ /**
+ * The signature covers the claims it was made over, so one token's signature does not carry
+ * another's claim set. A signature of the right length but over the wrong bytes passes a
+ * length check and fails here.
+ */
+ @ParameterizedTest
+ @EnumSource(WebIdentityTokenIssuer.Algorithm.class)
+ void aSignatureDoesNotCoverAnotherTokensClaims(WebIdentityTokenIssuer.Algorithm algorithm)
+ throws Exception {
+ String jwt = mint(algorithm, 300);
+ String longer = mint(algorithm, 3600);
+ assertNotEquals(segment(jwt, 1), segment(longer, 1));
+
+ String swapped = segment(jwt, 0) + "." + segment(longer, 1);
+
+ assertFalse(verifies(algorithm, swapped, signature(jwt)),
+ algorithm + " must not verify a claim set it did not sign");
+ }
+
+ /**
+ * One key per algorithm, minted on first use and stored rather than held in memory, so a
+ * restart does not invalidate a token already handed out.
+ */
+ @Test
+ void theKeyIsMintedOncePerAlgorithmAndStored() throws Exception {
+ String first = mint(WebIdentityTokenIssuer.Algorithm.RS256, 300);
+ String second = mint(WebIdentityTokenIssuer.Algorithm.RS256, 300);
+ String other = mint(WebIdentityTokenIssuer.Algorithm.ES384, 300);
+
+ assertEquals(keyId(first), keyId(second));
+ assertNotEquals(keyId(first), keyId(other));
+ assertEquals(keyId(first), keyStore.get("RS256").orElseThrow().getKeyId());
+ assertEquals(keyId(other), keyStore.get("ES384").orElseThrow().getKeyId());
+ }
+}