Comment puis-je vérifier un token D'accès à L'API d'authentification Google?

pour vérification par l'utilisateur, il suffit de poster obtenez le jeton d'accès comme accessstoken et postez-le et obtenez la réponse

https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=accessToken

vous pouvez essayer dans la barre d'adresse dans les navigateurs aussi, utiliser httppost et la réponse en java aussi

la réponse sera comme

{
     "issued_to": "xxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com",
     "audience": "xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com",
     "user_id": "xxxxxxxxxxxxxxxxxxxxxxx",
     "scope": "https://www.googleapis.com/auth/userinfo.profile https://gdata.youtube.com",
     "expires_in": 3340,
     "access_type": "offline"
    }

la portée est la permission donnée de l'accessToken. vous pouvez consulter les ID de champ d'application dans ce lien

function authenticate_google_OAuthtoken($user_id)
{
    $access_token   = google_get_user_token($user_id); // get existing token from DB
    $redirecturl    = $Google_Permissions->redirecturl;
    $client_id      = $Google_Permissions->client_id;
    $client_secret  = $Google_Permissions->client_secret;
    $redirect_uri   = $Google_Permissions->redirect_uri;
    $max_results    = $Google_Permissions->max_results;

    $url = 'https://www.googleapis.com/oauth2/v1/tokeninfo?access_token='.$access_token;
    $response_contacts  =  curl_get_responce_contents($url);
    $response   =   (json_decode($response_contacts));

    if(isset($response->issued_to))
    {
        return true;
    }
    else if(isset($response->error))
    {
        return false;
    }
}

vous pouvez vérifier un token D'accès d'authentification Google en utilisant ce endpoint:

https://www.googleapis.com/oauth2/v3/tokeninfo?access_token=<access_token>

C'est Google V3 OAuth AccessToken validation point de fin, vous pouvez vous référer au document de google ci-dessous: (dans OAUTH 2.0 ENDPOINTS onglet)

https://developers.google.com/identity/protocols/OAuth2UserAgent#validate-access-token

Google oauth flux de code de réponse en plus de access_token renvoie également id_token qui contient utile pour la validation de l'info sous forme cryptée.

une chose qui rend les jetons ID utiles est le fait que vous pouvez passer autour de différents composants de votre application. Ces composants peuvent utiliser un jeton D'identification comme mécanisme d'authentification léger l'application et l'utilisateur. Mais avant de pouvoir utiliser le informations dans la carte D'identité jeton ou compter sur elle comme une affirmation que l'utilisateur est authentifié, vous devez le valider.

la Validation d'un jeton D'identification nécessite plusieurs étapes:

• vérifier que le jeton ID est un JWT correctement signé avec une clé publique Google appropriée.
• vérifiez que la valeur d'aud dans le token ID est égale à l'ID client de votre application.
• vérifier que la valeur de iss dans le jeton ID est égale à accounts.google.com ou https://accounts.google.com .
• vérifier que le délai d'expiration (exp) du jeton ID n'est pas passé.
• si vous avez passé un paramètre hd dans la requête, vérifiez que le token ID possède une revendication hd qui correspond à votre domaine hébergé Googleapps.

https://developers.google.com/identity/protocols/OpenIDConnect#validatinganidtoken le lien contient des échantillons de code pour la validation des jetons D'identification.

Voir aussi https://security.stackexchange.com/questions/37818/why-use-openid-connect-instead-of-plain-oauth .

Ok, la plupart des réponses sont valables mais pas tout à fait correctes. L'idée de JWT est que vous pouvez valider le token sans avoir à contacter l'émetteur à chaque fois. Vous devez vérifier l'id et la signature du jeton avec la clé publique connue du certificat google utilisé pour signer le jeton.

Voir le prochain post, pourquoi et comment le faire.

http://ncona.com/2015/02/consuming-a-google-id-token-from-a-server /

je dois d'une manière ou d'une autre interroger Google et demander: Est-ce que ce token d'accès est valide pour example@example.com Je ne sais pas.

Pas de. Il vous suffit de demander une connexion standard avec Federated Login pour les utilisateurs du compte Google à partir de votre domaine API. Et ce n'est qu'après que vous pourrez comparer "persistent user ID" avec celui que vous avez à partir de "public interface".

la valeur de realm est utilisé sur le Google Federated Page de connexion pour identifier le site demandeur à l'utilisateur. Il est également utilisé pour déterminer la valeur de l'ID utilisateur persistant retourné par Google.

vous devez donc être du même domaine que 'interface publique'.

et n'oubliez pas que l'utilisateur doit être sûr que votre API peut être fiable ;) donc Google demandera à l'utilisateur si elle vous permet de vérifier son identité.

essayez de faire une demande authentifiée par OAuth en utilisant votre token à https://www.google.com/accounts/AuthSubTokenInfo . Cela ne fonctionne que pour AuthSub, mais cela fonctionne aussi pour OAuth. Il ne vous indiquera pas à quel utilisateur le token est destiné, mais il vous indiquera les services pour lesquels il est valide, et la requête échouera si le token est invalide ou a été révoqué.

un jeton d'accès arbitraire OAuth ne peut pas être utilisé pour l'authentification, parce que la signification du jeton est en dehors de la spécification du noyau OAuth. Il peut être destiné à un usage unique ou une fenêtre d'expiration étroite, ou il peut fournir un accès que l'utilisateur ne veut pas donner. Il est également opaque, et le consommateur qui l'a obtenu pourrait ne jamais avoir vu aucun type d'identificateur d'utilisateur.

un autre fournisseur de services et un ou plusieurs consommateurs pourraient facilement utiliser L'autre pour fournir un jeton d'authentification vérifiable, et il y a des propositions et des idées pour le faire là-bas, mais un fournisseur de services arbitraire parlant seulement OAuth Core ne peut pas fournir cela sans autre coordination avec un consommateur. La méthode AuthSubTokenInfo REST spécifique à Google, ainsi que l'identifiant de L'utilisateur, est proche, mais elle ne convient pas non plus, car elle pourrait invalider le token, ou le token pourrait être expiré.

si votre identifiant Google est un identifiant OpenId, et votre 'interface publique' est soit une application web, soit vous pouvez appeler le navigateur de L'utilisateur, alors vous devriez probablement utiliser OpenID OP de Google.

OpenID consiste simplement à envoyer l'utilisateur à L'OP et à récupérer une déclaration signée. L'interaction est uniquement au profit du pr. Il n'y a pas de jeton de longue durée ou d'autre poignée spécifique à l'utilisateur qui pourrait être utilisée pour indiquer qu'une RP a réussi à authentifier un utilisateur avec une OP.

une façon de vérifier une précédente l'authentification contre un identifiant OpenID doit simplement effectuer l'authentification à nouveau, en supposant que le même user-agent est utilisé. L'OP devrait être en mesure de retourner une affirmation positive sans interaction avec l'utilisateur (en vérifiant un cookie ou un client cert, par exemple). L'OP est libre d'exiger une autre interaction utilisateur, et le fera probablement si la demande d'authentification provient d'un autre domaine (mon OP me donne l'option de ré-authentifier cette RP particulière sans interagir à l'avenir). Et dans Dans le cas de Google, l'interface utilisateur que l'Utilisateur a utilisée pour obtenir le token OAuth pourrait ne pas utiliser le même identifiant de session, de sorte que l'Utilisateur devra se ré-authentifier. Mais dans tous les cas, vous serez en mesure d'affirmer l'identité.

Voici un exemple d'utilisation de Bouffer :

/**
 * @param string $accessToken JSON-encoded access token as returned by \Google_Client->getAccessToken() or raw access token
 * @return array|false False if token is invalid or array in the form
 * 
 * array (
 *   'issued_to' => 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com',
 *   'audience' => 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com',
 *   'scope' => 'https://www.googleapis.com/auth/calendar',
 *   'expires_in' => 3350,
 *   'access_type' => 'offline',
 * )
 */
public static function tokenInfo($accessToken) {
    if(!strlen($accessToken)) {
        return false;
    }

    if($accessToken[0] === '{') {
        $accessToken = json_decode($accessToken)->access_token;
    }

    $guzzle = new \GuzzleHttp\Client();

    try {
        $resp = $guzzle->get('https://www.googleapis.com/oauth2/v1/tokeninfo', [
            'query' => ['access_token' => $accessToken],
        ]);
    } catch(ClientException $ex) {
        return false;
    }

    return $resp->json();
}

essayer de faire une requête valide et vérifier pour une réponse de token invalide.

Google n'a jamais pu répondre à votre question, parce que ce n'est pas "ce token d'accès est-il valide?"C'est token+secret.