src/main/java/org/keycloak/protocol/cas/endpoints/AbstractValidateEndpoint.java

@@ -27,19 +27,30 @@
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.HttpResponse;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.keycloak.connections.httpclient.HttpClientProvider;

public abstract class AbstractValidateEndpoint {
    protected final Logger logger = Logger.getLogger(getClass());
    private static final Pattern DOT = Pattern.compile("\\.");
    private static final Pattern SEPERATION_PATTERN = Pattern.compile("--");
    private static final int PGT_CALLBACK_TIMEOUT_MS = 5000;
    private static final RequestConfig PGT_CALLBACK_REQUEST_CONFIG = RequestConfig.custom()
            .setConnectTimeout(PGT_CALLBACK_TIMEOUT_MS)
            .setConnectionRequestTimeout(PGT_CALLBACK_TIMEOUT_MS)
            .setSocketTimeout(PGT_CALLBACK_TIMEOUT_MS)
            .setRedirectsEnabled(false)
            .build();
    protected KeycloakSession session;
    protected RealmModel realm;
    protected EventBuilder event;
    protected ClientModel client;
    protected String service;
    protected AuthenticatedClientSessionModel clientSession;
    protected String pgtIou;

@@ -69,10 +80,7 @@

        event.detail(Details.REDIRECT_URI, service);

        client = realm.getClientsStream()
                .filter(c -> CASLoginProtocol.LOGIN_PROTOCOL.equals(c.getProtocol()))
                .filter(c -> RedirectUtils.verifyRedirectUri(session, service, c) != null)
                .findFirst().orElse(null);
        client = findClient(service);
        if (client == null) {
            event.error(Errors.CLIENT_NOT_FOUND);
            throw new CASValidationException(CASErrorCode.INVALID_SERVICE, "Client not found", Response.Status.BAD_REQUEST);
@@ -83,11 +91,20 @@
            throw new CASValidationException(CASErrorCode.INVALID_SERVICE, "Client disabled", Response.Status.BAD_REQUEST);
        }

        this.service = RedirectUtils.verifyRedirectUri(session, service, client);

        event.client(client.getClientId());

        session.getContext().setClient(client);
    }

    protected ClientModel findClient(String service) {
        return realm.getClientsStream()
                .filter(c -> CASLoginProtocol.LOGIN_PROTOCOL.equals(c.getProtocol()))
                .filter(c -> RedirectUtils.verifyRedirectUri(session, service, c) != null)
                .findFirst().orElse(null);
    }

    protected void checkTicket(String ticket, String prefix, boolean requireReauth) {
        if (ticket == null) {
            event.error(Errors.INVALID_CODE);
@@ -162,6 +179,12 @@
            throw new CASValidationException(CASErrorCode.INVALID_TICKET, "Code is expired", Response.Status.BAD_REQUEST);
        }

        // Service and proxy tickets are valid only for the service they were issued for
        if (!isReusable && (service == null || !service.equals(codeData.getRedirectUriParam()))) {
            event.error(Errors.INVALID_REDIRECT_URI);
            throw new CASValidationException(CASErrorCode.INVALID_SERVICE, "Ticket was not issued for this service", Response.Status.BAD_REQUEST);
        }

        clientSession.setNote(CASLoginProtocol.SESSION_TICKET, ticket);

        if (requireReauth && AuthenticationManager.isSSOAuthentication(clientSession)) {
@@ -184,7 +207,8 @@

        if (client == null) {
            client = clientSession.getClient();
        } else {
        } else if (!prefix.equals(CASLoginProtocol.PROXY_TICKET_PREFIX)) {
            // Proxy tickets are issued from the proxying client's session for a (possibly) different target service
            if (!client.getClientId().equals(clientSession.getClient().getClientId())) {
                event.error(Errors.INVALID_CODE);
                throw new CASValidationException(CASErrorCode.INVALID_SERVICE, "Invalid service", Response.Status.BAD_REQUEST);
@@ -213,16 +237,23 @@
        String pgtId  = getPGT(session, clientSession, pgtUrl);

        try {
            HttpResponse response = HttpClientBuilder.create().build().execute(
                new HttpGet(new URIBuilder(pgtUrl).setParameter("pgtIou",pgtIou).setParameter("pgtId",pgtId).build())
            );
            HttpGet request = new HttpGet(new URIBuilder(pgtUrl).setParameter("pgtIou",pgtIou).setParameter("pgtId",pgtId).build());
            request.setConfig(PGT_CALLBACK_REQUEST_CONFIG);

            if (response.getStatusLine().getStatusCode() != 200) {
                throw new Exception();
            HttpClient httpClient = session.getProvider(HttpClientProvider.class).getHttpClient();
            HttpResponse response = httpClient.execute(request);
            try {
                if (response.getStatusLine().getStatusCode() != 200) {
                    throw new Exception();
                }
            } finally {
                EntityUtils.consumeQuietly(response.getEntity());
            }

            this.pgtIou = pgtIou;
        } catch (Exception e) {
            // The PGT was not delivered, so do not leave it usable
            session.singleUseObjects().remove(pgtId.substring(0, pgtId.indexOf("--")));
            event.error(Errors.INVALID_REQUEST);
            throw new CASValidationException(CASErrorCode.PROXY_CALLBACK_ERROR, "Proxy callback returned an error", Response.Status.BAD_REQUEST);
        }