8000 Updating OIDCParameterizedScopeTest to the new test framework by PadzerButch · Pull Request #55010 · keycloak/keycloak · GitHub
[go: up one dir, main page]

Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
package org.keycloak.testframework.oauth;

public class DefaultOIDCClientApplicationProviderConfig implements OIDCClientApplicationProviderConfig {

@Override
public OIDCClientApplicationProviderConfiguration build() {
return new OIDCClientApplicationProviderConfiguration();
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -127,6 +127,12 @@ public Map<String, String> generateKeys(String jwaAlgorithm, String curve, Boole
return getKeysAsPem();
}

KeyData getFirstKey() {
synchronized (keys) {
return keys.isEmpty() ? null : keys.get(0);
}
}

public Map<String, String> getKeysAsPem() {
if (keys.isEmpty()) {
return Collections.emptyMap();
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@ public class OAuthTestFrameworkExtension implements TestFrameworkExtension {
public List<Supplier<?, ?>> suppliers() {
return List.of(new OAuthClientSupplier(), new TestAppSupplier(), new OAuthIdentityProviderSupplier(),
new CimdProviderSupplier(), new SectorIdentifierRedirectUrisSupplier(), new CibaProviderSupplier(),
new JwksProviderSupplier());
new JwksProviderSupplier(), new OIDCClientApplicationProviderSupplier());
}

}
Original file line number Diff line number Diff line change
@@ -0,0 +1,183 @@
package org.keycloak.testframework.oauth;

import java.io.Closeable;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import jakarta.ws.rs.BadRequestException;

import org.keycloak.common.util.KeyUtils;
import org.keycloak.crypto.Algorithm;
import org.keycloak.crypto.AsymmetricSignatureSignerContext;
import org.keycloak.crypto.JavaAlgorithm;
import org.keycloak.crypto.KeyType;
import org.keycloak.crypto.KeyUse;
import org.keycloak.crypto.KeyWrapper;
import org.keycloak.crypto.MacSignatureSignerContext;
import org.keycloak.crypto.ServerECDSASignatureSignerContext;
import org.keycloak.crypto.ServerEdDSASignatureSignerContext;
import org.keycloak.crypto.SignatureSignerContext;
import org.keycloak.jose.jws.JWSBuilder;
import org.keycloak.testframework.util.HttpServerUtil;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

/**
* Creates request objects and serves the registered JWT on the embedded test HTTP server.
*/
public class OIDCClientApplicationProvider implements Closeable {

public static final String CONTEXT = "/get-oidc-request";

private final HttpServer httpServer;
private final JwksProvider jwksProvider;
private final String signingAlgorithm;
private final Map<String, Object> defaultClaims;
private volatile String oidcRequest;

public OIDCClientApplicationProvider(HttpServer httpServer, JwksProvider jwksProvider) {
this(httpServer, jwksProvider, new DefaultOIDCClientApplicationProviderConfig().build());
}

public OIDCClientApplicationProvider(HttpServer httpServer, JwksProvider jwksProvider,
OIDCClientApplicationProviderConfiguration configuration) {
this.httpServer = httpServer;
this.jwksProvider = jwksProvider;
this.signingAlgorithm = configuration.getSigningAlgorithm();
this.defaultClaims = new HashMap<>(configuration.getClaims());
if (configuration.isGenerateInitialSigningKey() && !"none".equals(signingAlgorithm)) {
jwksProvider.generateKeys(signingAlgorithm, configuration.getCurve(), true, false, null);
}
httpServer.createContext(CONTEXT, new OIDCRequestHandler());
}

/**
* Creates a request from the configured defaults and per-request overrides without registering it.
*/
public String createRequest(Map<String, Object> overrides) {
Map<String, Object> request = new HashMap<>(defaultClaims);
request.putAll(overrides);
return signRequestObject(request, signingAlgorithm);
}

public void setRequest(Map<String, Object> overrides) {
oidcRequest = createRequest(overrides);
}

/**
* Signs exactly the supplied object, without adding configured claims or generating a new key.
* Uses the first key currently published by the JWKS provider.
*/
public String signRequestObject(Object requestObject, String algorithm) {
if (algorithm == null) {
throw new BadRequestException("Unknown argument: null");
}
switch (algorithm) {
case "none":
return new JWSBuilder().jsonContent(requestObject).none();
case Algorithm.RS256, Algorithm.RS384, Algorithm.RS512,
Algorithm.PS256, Algorithm.PS384, Algorithm.PS512,
Algorithm.ES256, Algorithm.ES384, Algorithm.ES512, Algorithm.EdDSA:
break;
default:
throw new BadRequestException("Unknown argument: " + algorithm);
}

JwksProvider.KeyData keyData = jwksProvider.getFirstKey();
if (keyData == null) {
throw new BadRequestException("signing key not set");
}

String kid = keyData.getKid() != null ? keyData.getKid() : KeyUtils.createKeyId(keyData.getKeyPair().getPublic());
KeyWrapper keyWrapper = new KeyWrapper();
keyWrapper.setAlgorithm(algorithm);
keyWrapper.setKid(kid);
keyWrapper.setPrivateKey(keyData.getKeyPair().getPrivate());

SignatureSignerContext signer = switch (algorithm) {
case Algorithm.ES256, Algorithm.ES384, Algorithm.ES512 -> new ServerECDSASignatureSignerContext(keyWrapper);
case Algorithm.EdDSA -> {
keyWrapper.setCurve(keyData.getCurve());
yield new ServerEdDSASignatureSignerContext(keyWrapper);
}
default -> new AsymmetricSignatureSignerContext(keyWrapper);
};
return new JWSBuilder().kid(kid).jsonContent(requestObject).sign(signer);
}

/**
* Signs using the supplied client secret, or creates an unsigned request when the algorithm is none.
*/
public String signRequestObject(Object requestObject, String algorithm, String clientSecret) {
if (algorithm == null) {
throw new BadRequestException("Unknown argument: null");
}
switch (algorithm) {
case "none":
return new JWSBuilder().jsonContent(requestObject).none();
case Algorithm.HS256, Algorithm.HS384, Algorithm.HS512:
break;
default:
throw new BadRequestException("Unknown jwaAlgorithm: " + algorithm);
}
if (clientSecret == null) {
throw new BadRequestException("client secret not set");
}

SecretKey secretKey = new SecretKeySpec(clientSecret.getBytes(StandardCharsets.UTF_8), JavaAlgorithm.getJavaAlgorithm(algorithm));
String kid = KeyUtils.createKeyId(secretKey);
KeyWrapper keyWrapper = new KeyWrapper();
keyWrapper.setSecretKey(secretKey);
keyWrapper.setKid(kid);
keyWrapper.setAlgorithm(algorithm);
keyWrapper.setUse(KeyUse.SIG);
keyWrapper.setType(KeyType.OCT);
return new JWSBuilder().kid(kid).jsonContent(requestObject).sign(new MacSignatureSignerContext(keyWrapper));
}

public void setOidcRequest(Object requestObject, String algorithm) {
oidcRequest = signRequestObject(requestObject, algorithm);
}

public void setOidcRequest(Object requestObject, String algorithm, String clientSecret) {
oidcRequest = signRequestObject(requestObject, algorithm, clientSecret);
}

public String getOidcRequest() {
return oidcRequest;
}

public void reset() {
oidcRequest = null;
}

public String getUri() {
return "http://127.0.0.1:" + httpServer.getAddress().getPort() + CONTEXT;
}

@Override
public void close() {
httpServer.removeContext(CONTEXT);
}

private class OIDCRequestHandler implements HttpHandler {

@Override
public void handle(HttpExchange exchange) throws IOException {
String request = oidcRequest;
if (request == null) {
HttpServerUtil.sendResponse(exchange, 404, null);
} else {
HttpServerUtil.sendResponse(exchange, 200,
Map.of("Content-Type", List.of("application/oauth-authz-req+jwt")), request);
}
}
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
package org.keycloak.testframework.oauth;

public interface OIDCClientApplicationProviderConfig {

OIDCClientApplicationProviderConfiguration build();
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
package org.keycloak.testframework.oauth;

import java.util.HashMap;
import java.util.Map;

/**
* Default request claims and signing settings. Creating this configuration does not register a request or generate a key.
*/
public class OIDCClientApplicationProviderConfiguration {

private Map<String, Object> claims = new HashMap<>();
private String signingAlgorithm = "none";
private String curve;
private boolean generateInitialSigningKey;

public Map<String, Object> getClaims() {
return claims;
}

public void setClaims(Map<String, Object> claims) {
this.claims = new HashMap<>(claims);
}

public String getClientId() {
return (String) claims.get("client_id");
}

public void setClientId(String clientId) {
claims.put("client_id", clientId);
}

public String getResponseType() {
return (String) claims.get("response_type");
}

public void setResponseType(String responseType) {
claims.put("response_type", responseType);
}

public String getScope() {
return (String) claims.get("scope");
}

public void setScope(String scope) {
claims.put("scope", scope);
}

public String getRedirectUri() {
return (String) claims.get("redirect_uri");
}

public void setRedirectUri(String redirectUri) {
claims.put("redirect_uri", redirectUri);
}

public String getSigningAlgorithm() {
return signingAlgorithm;
}

public void setSigningAlgorithm(String signingAlgorithm) {
this.signingAlgorithm = signingAlgorithm;
}

public String getCurve() {
return curve;
}

public void setCurve(String curve) {
this.curve = curve;
}

public boolean isGenerateInitialSigningKey() {
return generateInitialSigningKey;
}

public void setGenerateInitialSigningKey(boolean generateInitialSigningKey) {
this.generateInitialSigningKey = generateInitialSigningKey;
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,44 @@
package org.keycloak.testframework.oauth;

import java.util.List;

import org.keycloak.testframework.injection.DependenciesBuilder;
import org.keycloak.testframework.injection.Dependency;
import org.keycloak.testframework.injection.InstanceContext;
import org.keycloak.testframework.injection.RequestedInstance;
import org.keycloak.testframework.injection.Supplier;
import org.keycloak.testframework.injection.SupplierHelpers;
import org.keycloak.testframework.oauth.annotations.InjectOIDCClientApplicationProvider;

import com.sun.net.httpserver.HttpServer;

public class OIDCClientApplicationProviderSupplier implements Supplier<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> {

@Override
public List<Dependency> getDependencies(RequestedInstance<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> instanceContext) {
return DependenciesBuilder.create(HttpServer.class).add(JwksProvider.class).build();
}

@Override
public OIDCClientApplicationProvider getValue(InstanceContext<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> instanceContext) {
HttpServer httpServer = instanceContext.getDependency(HttpServer.class);
JwksProvider jwksProvider = instanceContext.getDependency(JwksProvider.class);
OIDCClientApplicationProviderConfig config = SupplierHelpers.getInstance(instanceContext.getAnnotation().config());
return new OIDCClientApplicationProvider(httpServer, jwksProvider, config.build());
}

@Override
public void onBeforeEach(InstanceContext<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> instanceContext) {
instanceContext.getValue().reset();
}

@Override
public void close(InstanceContext<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> instanceContext) {
instanceContext.getValue().close();
}

@Override
public boolean compatible(InstanceContext<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> a, RequestedInstance<OIDCClientApplicationProvider, InjectOIDCClientApplicationProvider> b) {
return a.getAnnotation().equals(b.getAnnotation());
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,19 @@
package org.keycloak.testframework.oauth.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.keycloak.testframework.injection.LifeCycle;
import org.keycloak.testframework.oauth.DefaultOIDCClientApplicationProviderConfig;
import org.keycloak.testframework.oauth.OIDCClientApplicationProviderConfig;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface InjectOIDCClientApplicationProvider {

LifeCycle lifecycle() default LifeCycle.GLOBAL;

Class<? extends OIDCClientApplicationProviderConfig> config() default DefaultOIDCClientApplicationProviderConfig.class;
}
Loading
Loading
0