OpenIDConnectClient.php

Go to the documentation of this file.

<?php
namespace Jumbojett;
 
if (!class_exists('\phpseclib\Crypt\RSA') && !class_exists('Crypt_RSA')) {
    user_error('Unable to find phpseclib Crypt/RSA.php.  Ensure phpseclib is installed and in include_path before you include this file');
}
 
function base64url_decode($base64url) {
    return base64_decode(b64url2b64($base64url));
}
 
function b64url2b64($base64url) {
    // "Shouldn't" be necessary, but why not
    $padding = strlen($base64url) % 4;
    if ($padding > 0) {
        $base64url .= str_repeat('=', 4 - $padding);
    }
    return strtr($base64url, '-_', '+/');
}
 
 
class OpenIDConnectClientException extends \Exception
{
 
}
 
if (!function_exists('curl_init')) {
    throw new OpenIDConnectClientException('OpenIDConnect needs the CURL PHP extension.');
}
if (!function_exists('json_decode')) {
    throw new OpenIDConnectClientException('OpenIDConnect needs the JSON PHP extension.');
}
 
class OpenIDConnectClient
{
 
    private $clientID;
 
    private $clientName;
 
    private $clientSecret;
 
    private $providerConfig = array();
 
    private $httpProxy;
 
    private $certPath;
 
    private $verifyPeer = true;
 
    private $verifyHost = true;
 
    protected $accessToken;
 
    private $refreshToken;
 
    protected $idToken;
 
    private $tokenResponse;
 
    private $scopes = array();
 
    private $responseCode;
 
    private $responseTypes = array();
 
    private $userInfo = array();
 
    private $authParams = array();
 
    private $registrationParams = array();
 
    private $wellKnown = false;
 
    private $wellKnownConfigParameters = array();
 
    protected $timeOut = 60;
 
    private $leeway = 300;
 
    private $additionalJwks = array();
 
    protected $verifiedClaims = array();
 
    private $issuerValidator;
 
    private $allowImplicitFlow = false;
    private $redirectURL;
 
    protected $enc_type = PHP_QUERY_RFC1738;
 
    private $codeChallengeMethod = false;
 
    private $pkceAlgs = array('S256' => 'sha256', 'plain' => false);
 
    public function __construct($provider_url = null, $client_id = null, $client_secret = null, $issuer = null) {
        $this->setProviderURL($provider_url);
        if ($issuer === null) {
            $this->setIssuer($provider_url);
        } else {
            $this->setIssuer($issuer);
        }
 
        $this->clientID = $client_id;
        $this->clientSecret = $client_secret;
 
        $this->issuerValidator = function($iss){
                return ($iss === $this->getIssuer() || $iss === $this->getWellKnownIssuer() || $iss === $this->getWellKnownIssuer(true));
        };
    }
 
    public function setProviderURL($provider_url) {
        $this->providerConfig['providerUrl'] = $provider_url;
    }
 
    public function setIssuer($issuer) {
        $this->providerConfig['issuer'] = $issuer;
    }
 
    public function setResponseTypes($response_types) {
        $this->responseTypes = array_merge($this->responseTypes, (array)$response_types);
    }
 
    public function authenticate() {
 
        // Do a preemptive check to see if the provider has thrown an error from a previous redirect
        if (isset($_REQUEST['error'])) {
            $desc = isset($_REQUEST['error_description']) ? ' Description: ' . $_REQUEST['error_description'] : '';
            throw new OpenIDConnectClientException('Error: ' . $_REQUEST['error'] .$desc);
        }
 
        // If we have an authorization code then proceed to request a token
        if (isset($_REQUEST['code'])) {
 
            $code = $_REQUEST['code'];
            $token_json = $this->requestTokens($code);
 
            // Throw an error if the server returns one
            if (isset($token_json->error)) {
                if (isset($token_json->error_description)) {
                    throw new OpenIDConnectClientException($token_json->error_description);
                }
                throw new OpenIDConnectClientException('Got response: ' . $token_json->error);
            }
 
            // Do an OpenID Connect session check
            if ($_REQUEST['state'] !== $this->getState()) {
                throw new OpenIDConnectClientException('Unable to determine state');
            }
 
            // Cleanup state
            $this->unsetState();
 
            if (!property_exists($token_json, 'id_token')) {
                throw new OpenIDConnectClientException('User did not authorize openid scope.');
            }
 
            $claims = $this->decodeJWT($token_json->id_token, 1);
 
            // Verify the signature
            if ($this->canVerifySignatures()) {
                if (!$this->getProviderConfigValue('jwks_uri')) {
                    throw new OpenIDConnectClientException ('Unable to verify signature due to no jwks_uri being defined');
                }
                if (!$this->verifyJWTsignature($token_json->id_token)) {
                    throw new OpenIDConnectClientException ('Unable to verify signature');
                }
            } else {
                user_error('Warning: JWT signature verification unavailable.');
            }
 
            // Save the id token
            $this->idToken = $token_json->id_token;
 
            // Save the access token
            $this->accessToken = $token_json->access_token;
 
            // If this is a valid claim
            if ($this->verifyJWTclaims($claims, $token_json->access_token)) {
 
                // Clean up the session a little
                $this->unsetNonce();
 
                // Save the full response
                $this->tokenResponse = $token_json;
 
                // Save the verified claims
                $this->verifiedClaims = $claims;
 
                // Save the refresh token, if we got one
                if (isset($token_json->refresh_token)) {
                    $this->refreshToken = $token_json->refresh_token;
                }
 
                // Success!
                return true;
 
            }
 
            throw new OpenIDConnectClientException ('Unable to verify JWT claims');
        }
 
        if ($this->allowImplicitFlow && isset($_REQUEST['id_token'])) {
            // if we have no code but an id_token use that
            $id_token = $_REQUEST['id_token'];
 
            $accessToken = null;
            if (isset($_REQUEST['access_token'])) {
                $accessToken = $_REQUEST['access_token'];
            }
 
            // Do an OpenID Connect session check
            if ($_REQUEST['state'] !== $this->getState()) {
                throw new OpenIDConnectClientException('Unable to determine state');
            }
 
            // Cleanup state
            $this->unsetState();
 
            $claims = $this->decodeJWT($id_token, 1);
 
            // Verify the signature
            if ($this->canVerifySignatures()) {
                if (!$this->getProviderConfigValue('jwks_uri')) {
                    throw new OpenIDConnectClientException ('Unable to verify signature due to no jwks_uri being defined');
                }
                if (!$this->verifyJWTsignature($id_token)) {
                    throw new OpenIDConnectClientException ('Unable to verify signature');
                }
            } else {
                user_error('Warning: JWT signature verification unavailable.');
            }
 
            // Save the id token
            $this->idToken = $id_token;
 
            // If this is a valid claim
            if ($this->verifyJWTclaims($claims, $accessToken)) {
 
                // Clean up the session a little
                $this->unsetNonce();
 
                // Save the verified claims
                $this->verifiedClaims = $claims;
 
                // Save the access token
                if ($accessToken) {
                    $this->accessToken = $accessToken;
                }
 
                // Success!
                return true;
 
            }
 
            throw new OpenIDConnectClientException ('Unable to verify JWT claims');
        }
 
        $this->requestAuthorization();
        return false;
 
    }
 
    public function signOut($accessToken, $redirect) {
        $signout_endpoint = $this->getProviderConfigValue('end_session_endpoint');
 
        $signout_params = null;
        if($redirect === null){
            $signout_params = array('id_token_hint' => $accessToken);
        }
        else {
            $signout_params = array(
                'id_token_hint' => $accessToken,
                'post_logout_redirect_uri' => $redirect);
        }
 
        $signout_endpoint  .= (strpos($signout_endpoint, '?') === false ? '?' : '&') . http_build_query( $signout_params, null, '&', $this->enc_type);
        $this->redirect($signout_endpoint);
    }
 
    public function addScope($scope) {
        $this->scopes = array_merge($this->scopes, (array)$scope);
    }
 
    public function addAuthParam($param) {
        $this->authParams = array_merge($this->authParams, (array)$param);
    }
 
    public function addRegistrationParam($param) {
        $this->registrationParams = array_merge($this->registrationParams, (array)$param);
    }
 
    protected function addAdditionalJwk($jwk) {
        $this->additionalJwks[] = $jwk;
    }
 
    protected function getProviderConfigValue($param, $default = null) {
 
        // If the configuration value is not available, attempt to fetch it from a well known config endpoint
        // This is also known as auto "discovery"
        if (!isset($this->providerConfig[$param])) {
            $this->providerConfig[$param] = $this->getWellKnownConfigValue($param, $default);
        }
 
        return $this->providerConfig[$param];
    }
 
    private function getWellKnownConfigValue($param, $default = null) {
 
        // If the configuration value is not available, attempt to fetch it from a well known config endpoint
        // This is also known as auto "discovery"
        if(!$this->wellKnown) {
            $well_known_config_url = rtrim($this->getProviderURL(), '/') . '/.well-known/openid-configuration';
            if (count($this->wellKnownConfigParameters) > 0){
                $well_known_config_url .= '?' .  http_build_query($this->wellKnownConfigParameters) ;
            }
            $this->wellKnown = json_decode($this->fetchURL($well_known_config_url));
        }
 
        $value = false;
        if(isset($this->wellKnown->{$param})){
            $value = $this->wellKnown->{$param};
        }
 
        if ($value) {
            return $value;
        }
 
        if (isset($default)) {
            // Uses default value if provided
            return $default;
        }
 
        throw new OpenIDConnectClientException("The provider {$param} could not be fetched. Make sure your provider has a well known configuration available.");
    }
 
    public function setWellKnownConfigParameters(array $params = []){
        $this->wellKnownConfigParameters=$params;
    }
 
 
    public function setRedirectURL ($url) {
        if (parse_url($url,PHP_URL_HOST) !== false) {
            $this->redirectURL = $url;
        }
    }
 
    public function getRedirectURL() {
 
        // If the redirect URL has been set then return it.
        if (property_exists($this, 'redirectURL') && $this->redirectURL) {
            return $this->redirectURL;
        }
 
        // Other-wise return the URL of the current page
 
        /*
         * Compatibility with multiple host headers.
         * The problem with SSL over port 80 is resolved and non-SSL over port 443.
         * Support of 'ProxyReverse' configurations.
         */
 
        if (isset($_SERVER['HTTP_UPGRADE_INSECURE_REQUESTS']) && ($_SERVER['HTTP_UPGRADE_INSECURE_REQUESTS'] === '1')) {
            $protocol = 'https';
        } else {
            $protocol = @$_SERVER['HTTP_X_FORWARDED_PROTO']
                ?: @$_SERVER['REQUEST_SCHEME']
                    ?: ((isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on') ? 'https' : 'http');
        }
 
        $port = @intval($_SERVER['HTTP_X_FORWARDED_PORT'])
            ?: @intval($_SERVER['SERVER_PORT'])
                ?: (($protocol === 'https') ? 443 : 80);
 
        $host = @explode(':', $_SERVER['HTTP_HOST'])[0]
            ?: @$_SERVER['SERVER_NAME']
                ?: @$_SERVER['SERVER_ADDR'];
 
        $port = (443 === $port) || (80 === $port) ? '' : ':' . $port;
 
        return sprintf('%s://%s%s/%s', $protocol, $host, $port, @trim(reset(explode('?', $_SERVER['REQUEST_URI'])), '/'));
    }
 
    protected function generateRandString() {
        // Error and Exception need to be catched in this order, see https://github.com/paragonie/random_compat/blob/master/README.md
        // random_compat polyfill library should be removed if support for PHP versions < 7 is dropped
        try {
            return \bin2hex(\random_bytes(16));
        } catch (Error $e) {
            throw new OpenIDConnectClientException('Random token generation failed.');
        } catch (Exception $e) {
            throw new OpenIDConnectClientException('Random token generation failed.');
        };
    }
 
    private function requestAuthorization() {
 
        $auth_endpoint = $this->getProviderConfigValue('authorization_endpoint');
        $response_type = 'code';
 
        // Generate and store a nonce in the session
        // The nonce is an arbitrary value
        $nonce = $this->setNonce($this->generateRandString());
 
        // State essentially acts as a session key for OIDC
        $state = $this->setState($this->generateRandString());
 
        $auth_params = array_merge($this->authParams, array(
            'response_type' => $response_type,
            'redirect_uri' => $this->getRedirectURL(),
            'client_id' => $this->clientID,
            'nonce' => $nonce,
            'state' => $state,
            'scope' => 'openid'
        ));
 
        // If the client has been registered with additional scopes
        if (count($this->scopes) > 0) {
            $auth_params = array_merge($auth_params, array('scope' => implode(' ', array_merge($this->scopes, array('openid')))));
        }
 
        // If the client has been registered with additional response types
        if (count($this->responseTypes) > 0) {
            $auth_params = array_merge($auth_params, array('response_type' => implode(' ', $this->responseTypes)));
        }
 
        // If the client supports Proof Key for Code Exchange (PKCE)
        if (!empty($this->getCodeChallengeMethod()) && in_array($this->getCodeChallengeMethod(), $this->getProviderConfigValue('code_challenge_methods_supported'))) {
            $codeVerifier = bin2hex(random_bytes(64));
            $this->setCodeVerifier($codeVerifier);
            if (!empty($this->pkceAlgs[$this->getCodeChallengeMethod()])) {
                $codeChallenge = rtrim(strtr(base64_encode(hash($this->pkceAlgs[$this->getCodeChallengeMethod()], $codeVerifier, true)), '+/', '-_'), '=');
            } else {
                $codeChallenge = $codeVerifier;
            }
            $auth_params = array_merge($auth_params, array(
                'code_challenge' => $codeChallenge,
                'code_challenge_method' => $this->getCodeChallengeMethod()
            ));
        }
 
        $auth_endpoint .= (strpos($auth_endpoint, '?') === false ? '?' : '&') . http_build_query($auth_params, null, '&', $this->enc_type);
 
        $this->commitSession();
        $this->redirect($auth_endpoint);
    }
 
    public function requestClientCredentialsToken() {
        $token_endpoint = $this->getProviderConfigValue('token_endpoint');
 
        $headers = [];
 
        $grant_type = 'client_credentials';
 
        $post_data = array(
            'grant_type'    => $grant_type,
            'client_id'     => $this->clientID,
            'client_secret' => $this->clientSecret,
            'scope'         => implode(' ', $this->scopes)
        );
 
        // Convert token params to string format
        $post_params = http_build_query($post_data, null, '&', $this->enc_type);
 
        return json_decode($this->fetchURL($token_endpoint, $post_params, $headers));
    }
 
 
    public function requestResourceOwnerToken($bClientAuth =  FALSE) {
        $token_endpoint = $this->getProviderConfigValue('token_endpoint');
 
        $headers = [];
 
        $grant_type = 'password';
 
        $post_data = array(
            'grant_type'    => $grant_type,
            'username'      => $this->authParams['username'],
            'password'      => $this->authParams['password'],
            'scope'         => implode(' ', $this->scopes)
        );
 
        //For client authentication include the client values
        if($bClientAuth) {
            $post_data['client_id']     = $this->clientID;
            $post_data['client_secret'] = $this->clientSecret;
        }
 
        // Convert token params to string format
        $post_params = http_build_query($post_data, null, '&', $this->enc_type);
 
        return json_decode($this->fetchURL($token_endpoint, $post_params, $headers));
    }
 
 
    protected function requestTokens($code) {
        $token_endpoint = $this->getProviderConfigValue('token_endpoint');
        $token_endpoint_auth_methods_supported = $this->getProviderConfigValue('token_endpoint_auth_methods_supported', ['client_secret_basic']);
 
        $headers = [];
 
        $grant_type = 'authorization_code';
 
        $token_params = array(
            'grant_type' => $grant_type,
            'code' => $code,
            'redirect_uri' => $this->getRedirectURL(),
            'client_id' => $this->clientID,
            'client_secret' => $this->clientSecret
        );
 
        # Consider Basic authentication if provider config is set this way
        if (in_array('client_secret_basic', $token_endpoint_auth_methods_supported, true)) {
            $headers = ['Authorization: Basic ' . base64_encode(urlencode($this->clientID) . ':' . urlencode($this->clientSecret))];
            unset($token_params['client_secret']);
                unset($token_params['client_id']);
        }
 
        if (!empty($this->getCodeChallengeMethod()) && !empty($this->getCodeVerifier())) {
            $headers = [];
            unset($token_params['client_secret']);
            $token_params = array_merge($token_params, array(
                'client_id' => $this->clientID,
                'code_verifier' => $this->getCodeVerifier()
            ));
        }
 
        // Convert token params to string format
        $token_params = http_build_query($token_params, null, '&', $this->enc_type);
 
        $this->tokenResponse = json_decode($this->fetchURL($token_endpoint, $token_params, $headers));
 
        return $this->tokenResponse;
    }
 
    public function refreshToken($refresh_token) {
        $token_endpoint = $this->getProviderConfigValue('token_endpoint');
 
        $grant_type = 'refresh_token';
 
        $token_params = array(
            'grant_type' => $grant_type,
            'refresh_token' => $refresh_token,
            'client_id' => $this->clientID,
            'client_secret' => $this->clientSecret,
        );
 
        // Convert token params to string format
        $token_params = http_build_query($token_params, null, '&', $this->enc_type);
 
        $json = json_decode($this->fetchURL($token_endpoint, $token_params));
 
        if (isset($json->access_token)) {
            $this->accessToken = $json->access_token;
        }
 
        if (isset($json->refresh_token)) {
            $this->refreshToken = $json->refresh_token;
        }
 
        return $json;
    }
 
    private function get_key_for_header($keys, $header) {
        foreach ($keys as $key) {
            if ($key->kty === 'RSA') {
                if (!isset($header->kid) || $key->kid === $header->kid) {
                    return $key;
                }
            } else {
                if (isset($key->alg) && $key->alg === $header->alg && $key->kid === $header->kid) {
                    return $key;
                }
            }
        }
        if ($this->additionalJwks) {
            foreach ($this->additionalJwks as $key) {
                if ($key->kty === 'RSA') {
                    if (!isset($header->kid) || $key->kid === $header->kid) {
                        return $key;
                    }
                } else {
                    if (isset($key->alg) && $key->alg === $header->alg && $key->kid === $header->kid) {
                        return $key;
                    }
                }
            }
        }
        if (isset($header->kid)) {
            throw new OpenIDConnectClientException('Unable to find a key for (algorithm, kid):' . $header->alg . ', ' . $header->kid . ')');
        }
 
        throw new OpenIDConnectClientException('Unable to find a key for RSA');
    }
 
 
    private function verifyRSAJWTsignature($hashtype, $key, $payload, $signature, $signatureType) {
        if (!class_exists('\phpseclib\Crypt\RSA') && !class_exists('Crypt_RSA')) {
            throw new OpenIDConnectClientException('Crypt_RSA support unavailable.');
        }
        if (!(property_exists($key, 'n') && property_exists($key, 'e'))) {
            throw new OpenIDConnectClientException('Malformed key object');
        }
 
        /* We already have base64url-encoded data, so re-encode it as
           regular base64 and use the XML key format for simplicity.
        */
        $public_key_xml = "<RSAKeyValue>\r\n".
            '  <Modulus>' . b64url2b64($key->n) . "</Modulus>\r\n" .
            '  <Exponent>' . b64url2b64($key->e) . "</Exponent>\r\n" .
            '</RSAKeyValue>';
        if(class_exists('Crypt_RSA', false)) {
            $rsa = new Crypt_RSA();
            $rsa->setHash($hashtype);
            if ($signatureType === 'PSS') {
                $rsa->setMGFHash($hashtype);
            }
            $rsa->loadKey($public_key_xml, Crypt_RSA::PUBLIC_FORMAT_XML);
            $rsa->signatureMode = $signatureType === 'PSS' ? Crypt_RSA::SIGNATURE_PSS : Crypt_RSA::SIGNATURE_PKCS1;
        } else {
            $rsa = new \phpseclib\Crypt\RSA();
            $rsa->setHash($hashtype);
            if ($signatureType === 'PSS') {
                $rsa->setMGFHash($hashtype);
            }
            $rsa->loadKey($public_key_xml, \phpseclib\Crypt\RSA::PUBLIC_FORMAT_XML);
            $rsa->signatureMode = $signatureType === 'PSS' ? \phpseclib\Crypt\RSA::SIGNATURE_PSS : \phpseclib\Crypt\RSA::SIGNATURE_PKCS1;
        }
        return $rsa->verify($payload, $signature);
    }
 
    private function verifyHMACJWTsignature($hashtype, $key, $payload, $signature)
    {
        if (!function_exists('hash_hmac')) {
            throw new OpenIDConnectClientException('hash_hmac support unavailable.');
        }
 
        $expected=hash_hmac($hashtype, $payload, $key, true);
 
        if (function_exists('hash_equals')) {
            return hash_equals($signature, $expected);
        }
 
        return self::hashEquals($signature, $expected);
    }
 
    public function verifyJWTsignature($jwt) {
        if (!\is_string($jwt)) {
            throw new OpenIDConnectClientException('Error token is not a string');
        }
        $parts = explode('.', $jwt);
        if (!isset($parts[0])) {
            throw new OpenIDConnectClientException('Error missing part 0 in token');
        }
        $signature = base64url_decode(array_pop($parts));
        if (false === $signature || '' === $signature) {
            throw new OpenIDConnectClientException('Error decoding signature from token');
        }
        $header = json_decode(base64url_decode($parts[0]));
        if (null === $header || !\is_object($header)) {
            throw new OpenIDConnectClientException('Error decoding JSON from token header');
        }
        $payload = implode('.', $parts);
        $jwks = json_decode($this->fetchURL($this->getProviderConfigValue('jwks_uri')));
        if ($jwks === NULL) {
            throw new OpenIDConnectClientException('Error decoding JSON from jwks_uri');
        }
        if (!isset($header->alg)) {
            throw new OpenIDConnectClientException('Error missing signature type in token header');
        }
        switch ($header->alg) {
            case 'RS256':
            case 'PS256':
            case 'RS384':
            case 'RS512':
                $hashtype = 'sha' . substr($header->alg, 2);
                $signatureType = $header->alg === 'PS256' ? 'PSS' : '';
 
                $verified = $this->verifyRSAJWTsignature($hashtype,
                    $this->get_key_for_header($jwks->keys, $header),
                    $payload, $signature, $signatureType);
                break;
            case 'HS256':
            case 'HS512':
            case 'HS384':
                $hashtype = 'SHA' . substr($header->alg, 2);
                $verified = $this->verifyHMACJWTsignature($hashtype, $this->getClientSecret(), $payload, $signature);
                break;
            default:
                throw new OpenIDConnectClientException('No support for signature type: ' . $header->alg);
        }
        return $verified;
    }
 
    protected function verifyJWTclaims($claims, $accessToken = null) {
        if(isset($claims->at_hash) && isset($accessToken)){
            if(isset($this->getIdTokenHeader()->alg) && $this->getIdTokenHeader()->alg !== 'none'){
                $bit = substr($this->getIdTokenHeader()->alg, 2, 3);
            }else{
                // TODO: Error case. throw exception???
                $bit = '256';
            }
            $len = ((int)$bit)/16;
            $expected_at_hash = $this->urlEncode(substr(hash('sha'.$bit, $accessToken, true), 0, $len));
        }
        return (($this->issuerValidator->__invoke($claims->iss))
            && (($claims->aud === $this->clientID) || in_array($this->clientID, $claims->aud, true))
            && ($claims->nonce === $this->getNonce())
            && ( !isset($claims->exp) || ((gettype($claims->exp) === 'integer') && ($claims->exp >= time() - $this->leeway)))
            && ( !isset($claims->nbf) || ((gettype($claims->nbf) === 'integer') && ($claims->nbf <= time() + $this->leeway)))
            && ( !isset($claims->at_hash) || $claims->at_hash === $expected_at_hash )
        );
    }
 
    protected function urlEncode($str) {
        $enc = base64_encode($str);
        $enc = rtrim($enc, '=');
        $enc = strtr($enc, '+/', '-_');
        return $enc;
    }
 
    protected function decodeJWT($jwt, $section = 0) {
 
        $parts = explode('.', $jwt);
        return json_decode(base64url_decode($parts[$section]));
    }
 
    public function requestUserInfo($attribute = null) {
 
        $user_info_endpoint = $this->getProviderConfigValue('userinfo_endpoint');
        $schema = 'openid';
 
        $user_info_endpoint .= '?schema=' . $schema;
 
        //The accessToken has to be sent in the Authorization header.
        // Accept json to indicate response type
        $headers = ["Authorization: Bearer {$this->accessToken}",
            'Accept: application/json'];
 
        $user_json = json_decode($this->fetchURL($user_info_endpoint,null,$headers));
        if ($this->getResponseCode() <> 200) {
            throw new OpenIDConnectClientException('The communication to retrieve user data has failed with status code '.$this->getResponseCode());
        }
        $this->userInfo = $user_json;
 
        if($attribute === null) {
            return $this->userInfo;
        }
 
        if (property_exists($this->userInfo, $attribute)) {
            return $this->userInfo->$attribute;
        }
 
        return null;
    }
 
    public function getVerifiedClaims($attribute = null) {
 
        if($attribute === null) {
            return $this->verifiedClaims;
        }
 
        if (property_exists($this->verifiedClaims, $attribute)) {
            return $this->verifiedClaims->$attribute;
        }
 
        return null;
    }
 
    protected function fetchURL($url, $post_body = null, $headers = array()) {
 
 
        // OK cool - then let's create a new cURL resource handle
        $ch = curl_init();
 
        // Determine whether this is a GET or POST
        if ($post_body !== null) {
            // curl_setopt($ch, CURLOPT_POST, 1);
            // Alows to keep the POST method even after redirect
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
            curl_setopt($ch, CURLOPT_POSTFIELDS, $post_body);
 
            // Default content type is form encoded
            $content_type = 'application/x-www-form-urlencoded';
 
            // Determine if this is a JSON payload and add the appropriate content type
            if (is_object(json_decode($post_body))) {
                $content_type = 'application/json';
            }
 
            // Add POST-specific headers
            $headers[] = "Content-Type: {$content_type}";
 
        }
 
        // If we set some headers include them
        if(count($headers) > 0) {
            curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        }
 
        // Set URL to download
        curl_setopt($ch, CURLOPT_URL, $url);
 
        if (isset($this->httpProxy)) {
            curl_setopt($ch, CURLOPT_PROXY, $this->httpProxy);
        }
 
        // Include header in result? (0 = yes, 1 = no)
        curl_setopt($ch, CURLOPT_HEADER, 0);
 
        // Allows to follow redirect
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
 
        if (isset($this->certPath)) {
            curl_setopt($ch, CURLOPT_CAINFO, $this->certPath);
        }
 
        if($this->verifyHost) {
            curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
        } else {
            curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
        }
 
        if($this->verifyPeer) {
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
        } else {
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        }
 
        // Should cURL return or print out the data? (true = return, false = print)
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 
        // Timeout in seconds
        curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeOut);
 
        // Download the given URL, and return output
        $output = curl_exec($ch);
 
        // HTTP Response code from server may be required from subclass
        $info = curl_getinfo($ch);
        $this->responseCode = $info['http_code'];
 
        if ($output === false) {
            throw new OpenIDConnectClientException('Curl error: (' . curl_errno($ch) . ') ' . curl_error($ch));
        }
 
        // Close the cURL resource, and free system resources
        curl_close($ch);
 
        return $output;
    }
 
    public function getWellKnownIssuer($appendSlash = false) {
 
        return $this->getWellKnownConfigValue('issuer') . ($appendSlash ? '/' : '');
    }
 
    public function getIssuer() {
 
        if (!isset($this->providerConfig['issuer'])) {
            throw new OpenIDConnectClientException('The issuer has not been set');
        }
 
        return $this->providerConfig['issuer'];
    }
 
    public function getProviderURL() {
        if (!isset($this->providerConfig['providerUrl'])) {
            throw new OpenIDConnectClientException('The provider URL has not been set');
        }
 
        return $this->providerConfig['providerUrl'];
    }
 
    public function redirect($url) {
        header('Location: ' . $url);
        exit;
    }
 
    public function setHttpProxy($httpProxy) {
        $this->httpProxy = $httpProxy;
    }
 
    public function setCertPath($certPath) {
        $this->certPath = $certPath;
    }
 
    public function getCertPath()
    {
        return $this->certPath;
    }
 
    public function setVerifyPeer($verifyPeer) {
        $this->verifyPeer = $verifyPeer;
    }
 
    public function setVerifyHost($verifyHost) {
        $this->verifyHost = $verifyHost;
    }
 
    public function getVerifyHost()
    {
        return $this->verifyHost;
    }
 
    public function getVerifyPeer()
    {
        return $this->verifyPeer;
    }
 
    public function setIssuerValidator($issuerValidator){
        $this->issuerValidator = $issuerValidator;
    }
 
    public function setAllowImplicitFlow($allowImplicitFlow) {
        $this->allowImplicitFlow = $allowImplicitFlow;
    }
 
    public function getAllowImplicitFlow()
    {
        return $this->allowImplicitFlow;
    }
 
    public function providerConfigParam($array) {
        $this->providerConfig = array_merge($this->providerConfig, $array);
    }
 
    public function setClientSecret($clientSecret) {
        $this->clientSecret = $clientSecret;
    }
 
    public function setClientID($clientID) {
        $this->clientID = $clientID;
    }
 
 
    public function register() {
 
        $registration_endpoint = $this->getProviderConfigValue('registration_endpoint');
 
        $send_object = (object ) array_merge($this->registrationParams, array(
            'redirect_uris' => array($this->getRedirectURL()),
            'client_name' => $this->getClientName()
        ));
 
        $response = $this->fetchURL($registration_endpoint, json_encode($send_object));
 
        $json_response = json_decode($response);
 
        // Throw some errors if we encounter them
        if ($json_response === false) {
            throw new OpenIDConnectClientException('Error registering: JSON response received from the server was invalid.');
        }
 
        if (isset($json_response->{'error_description'})) {
            throw new OpenIDConnectClientException($json_response->{'error_description'});
        }
 
        $this->setClientID($json_response->{'client_id'});
 
        // The OpenID Connect Dynamic registration protocol makes the client secret optional
        // and provides a registration access token and URI endpoint if it is not present
        if (isset($json_response->{'client_secret'})) {
            $this->setClientSecret($json_response->{'client_secret'});
        } else {
            throw new OpenIDConnectClientException('Error registering:
                                                    Please contact the OpenID Connect provider and obtain a Client ID and Secret directly from them');
        }
 
    }
 
    public function introspectToken($token, $token_type_hint = '', $clientId = null, $clientSecret = null) {
        $introspection_endpoint = $this->getProviderConfigValue('introspection_endpoint');
 
        $post_data = array(
            'token'    => $token,
        );
        if ($token_type_hint) {
            $post_data['token_type_hint'] = $token_type_hint;
        }
        $clientId = $clientId !== null ? $clientId : $this->clientID;
        $clientSecret = $clientSecret !== null ? $clientSecret : $this->clientSecret;
 
        // Convert token params to string format
        $post_params = http_build_query($post_data, null, '&');
        $headers = ['Authorization: Basic ' . base64_encode(urlencode($clientId) . ':' . urlencode($clientSecret)),
            'Accept: application/json'];
 
        return json_decode($this->fetchURL($introspection_endpoint, $post_params, $headers));
    }
 
    public function revokeToken($token, $token_type_hint = '', $clientId = null, $clientSecret = null) {
        $revocation_endpoint = $this->getProviderConfigValue('revocation_endpoint');
 
        $post_data = array(
            'token'    => $token,
        );
        if ($token_type_hint) {
            $post_data['token_type_hint'] = $token_type_hint;
        }
        $clientId = $clientId !== null ? $clientId : $this->clientID;
        $clientSecret = $clientSecret !== null ? $clientSecret : $this->clientSecret;
 
        // Convert token params to string format
        $post_params = http_build_query($post_data, null, '&');
        $headers = ['Authorization: Basic ' . base64_encode(urlencode($clientId) . ':' . urlencode($clientSecret)),
            'Accept: application/json'];
 
        return json_decode($this->fetchURL($revocation_endpoint, $post_params, $headers));
    }
 
    public function getClientName() {
        return $this->clientName;
    }
 
    public function setClientName($clientName) {
        $this->clientName = $clientName;
    }
 
    public function getClientID() {
        return $this->clientID;
    }
 
    public function getClientSecret() {
        return $this->clientSecret;
    }
 
    public function canVerifySignatures() {
        return class_exists('\phpseclib\Crypt\RSA') || class_exists('Crypt_RSA');
    }
 
    public function setAccessToken($accessToken) {
        $this->accessToken = $accessToken;
    }
 
    public function getAccessToken() {
        return $this->accessToken;
    }
 
    public function getRefreshToken() {
        return $this->refreshToken;
    }
 
    public function getIdToken() {
        return $this->idToken;
    }
 
    public function getAccessTokenHeader() {
        return $this->decodeJWT($this->accessToken);
    }
 
    public function getAccessTokenPayload() {
        return $this->decodeJWT($this->accessToken, 1);
    }
 
    public function getIdTokenHeader() {
        return $this->decodeJWT($this->idToken);
    }
 
    public function getIdTokenPayload() {
        return $this->decodeJWT($this->idToken, 1);
    }
 
    public function getTokenResponse() {
        return $this->tokenResponse;
    }
 
    protected function setNonce($nonce) {
        $this->setSessionKey('openid_connect_nonce', $nonce);
        return $nonce;
    }
 
    protected function getNonce() {
        return $this->getSessionKey('openid_connect_nonce');
    }
 
    protected function unsetNonce() {
        $this->unsetSessionKey('openid_connect_nonce');
    }
 
    protected function setState($state) {
        $this->setSessionKey('openid_connect_state', $state);
        return $state;
    }
 
    protected function getState() {
        return $this->getSessionKey('openid_connect_state');
    }
 
    protected function unsetState() {
        $this->unsetSessionKey('openid_connect_state');
    }
 
    protected function setCodeVerifier($codeVerifier) {
        $this->setSessionKey('openid_connect_code_verifier', $codeVerifier);
        return $codeVerifier;
    }
 
    protected function getCodeVerifier() {
        return $this->getSessionKey('openid_connect_code_verifier');
    }
 
    protected function unsetCodeVerifier() {
        $this->unsetSessionKey('openid_connect_code_verifier');
    }
 
    public function getResponseCode()
    {
        return $this->responseCode;
    }
 
    public function setTimeout($timeout)
    {
        $this->timeOut = $timeout;
    }
 
    public function getTimeout()
    {
        return $this->timeOut;
    }
 
    private static function safeLength($str)
    {
        if (function_exists('mb_strlen')) {
            return mb_strlen($str, '8bit');
        }
        return strlen($str);
    }
 
    private static function hashEquals($str1, $str2)
    {
        $len1=static::safeLength($str1);
        $len2=static::safeLength($str2);
 
        //compare strings without any early abort...
        $len = min($len1, $len2);
        $status = 0;
        for ($i = 0; $i < $len; $i++) {
            $status |= (ord($str1[$i]) ^ ord($str2[$i]));
        }
        //if strings were different lengths, we fail
        $status |= ($len1 ^ $len2);
        return ($status === 0);
    }
 
    protected function startSession() {
        if (!isset($_SESSION)) {
            @session_start();
        }
    }
 
    protected function commitSession() {
        $this->startSession();
 
        session_write_close();
    }
 
    protected function getSessionKey($key) {
        $this->startSession();
 
        return $_SESSION[$key];
    }
 
    protected function setSessionKey($key, $value) {
        $this->startSession();
 
        $_SESSION[$key] = $value;
    }
 
    protected function unsetSessionKey($key) {
        $this->startSession();
 
        unset($_SESSION[$key]);
    }
 
    public function setUrlEncoding($curEncoding)
    {
        switch ($curEncoding)
        {
            case PHP_QUERY_RFC1738:
                $this->enc_type = PHP_QUERY_RFC1738;
                break;
 
            case PHP_QUERY_RFC3986:
                $this->enc_type = PHP_QUERY_RFC3986;
                break;
 
                default:
                break;
        }
 
    }
 
    public function getScopes()
    {
        return $this->scopes;
    }
 
    public function getResponseTypes()
    {
        return $this->responseTypes;
    }
 
    public function getAuthParams()
    {
        return $this->authParams;
    }
 
    public function getIssuerValidator()
    {
        return $this->issuerValidator;
    }
 
    public function getLeeway()
    {
        return $this->leeway;
    }
 
    public function getCodeChallengeMethod() {
        return $this->codeChallengeMethod;
    }
 
    public function setCodeChallengeMethod($codeChallengeMethod) {
        $this->codeChallengeMethod = $codeChallengeMethod;
    }
}