web services - test - Comment puis-je vérifier un jeton d'accès à l'API d'authentification Google?




token authentication android (8)

Je dois en quelque sorte interroger Google et demander: Est-ce que ce jeton d'accès est valide pour [email protected]?

Non. Tout ce dont vous avez besoin est de demander une connexion standard avec Connexion fédérée pour les utilisateurs de compte Google de votre domaine API. Et seulement après cela, vous pouvez comparer "ID utilisateur persistant" avec celui que vous avez de "l'interface publique".

La valeur du domaine est utilisée sur la page de connexion Google Federated pour identifier le site demandeur auprès de l'utilisateur. Il est également utilisé pour déterminer la valeur de l'ID utilisateur persistant renvoyé par Google.

Vous devez donc appartenir au même domaine que l'interface publique.

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

Comment puis-je vérifier un jeton d'accès à l'authentification Google?

Je dois en quelque sorte interroger Google et demander: Est-ce que [jeton d'accès donné] est valide pour le compte Google [[email protected]]?

Version courte :
La façon dont un jeton d'accès fourni via l' authentification Google Api :: OAuth pour les applications Web peut être utilisée pour demander des données à partir d'une gamme de services Google s'affiche clairement. Il n'est pas clair comment vérifier si un jeton d'accès donné est valide pour un compte Google donné. J'aimerais savoir comment.

Version longue :
Je développe une API qui utilise l'authentification par jeton. Un jeton sera retourné sur la fourniture d'un nom d'utilisateur + mot de passe valide ou sur la fourniture d'un jeton tiers à partir de l'un des N services vérifiables.

L'un des services tiers sera Google, permettant à un utilisateur de s'authentifier auprès de mon service en utilisant son compte Google. Cela sera ensuite étendu pour inclure les comptes Yahoo, les fournisseurs OpenID fiables et ainsi de suite.

Exemple schématique d'accès basé sur Google:

alt text http://webignition.net/images/figures/auth_figure002.png

L'entité 'API' est sous mon contrôle total. L'entité «interface publique» est une application Web ou de bureau. Certaines interfaces publiques sont sous mon contrôle, d'autres ne le seront pas et d'autres encore que je ne connaîtrai jamais.

Par conséquent, je ne peux pas faire confiance au jeton fourni à l'API à l'étape 3. Celui-ci sera fourni avec l'adresse e-mail du compte Google correspondant.

Je dois en quelque sorte interroger Google et demander: Est-ce que ce jeton d'accès est valide pour [email protected] ?

Dans ce cas, [email protected] est l'identifiant unique du compte Google, l'adresse e-mail utilisée pour se connecter à son compte Google. Cela ne peut pas être considéré comme une adresse Gmail - quelqu'un peut avoir un compte Google sans avoir un compte Gmail.

La documentation Google indique clairement comment, avec un jeton d'accès, les données peuvent être extraites d'un certain nombre de services Google. Rien ne semble indiquer comment vous pouvez vérifier si un jeton d'accès donné est valide en premier lieu.

Mise à jour Le jeton est valable pour N services Google. Je ne peux pas essayer un jeton contre un service Google comme moyen de le vérifier car je ne saurai pas quel sous-ensemble de tous les services de Google un utilisateur donné utilise effectivement.

De plus, je n'utiliserai jamais le jeton d'accès à l'authentification Google pour accéder à des services Google, mais simplement pour vérifier si un utilisateur supposé de Google est bien ce qu'il prétend être. S'il y a une autre façon de faire cela, je suis heureux d'essayer.


Essayez d'effectuer une demande authentifiée par OAuth à l'aide de votre jeton à l' https://www.google.com/accounts/AuthSubTokenInfo . Cela est uniquement documenté pour fonctionner avec AuthSub, mais cela fonctionne aussi pour OAuth. Il ne vous dira pas pour quel utilisateur le jeton est destiné, mais il vous indiquera pour quels services il est valide, et la requête échouera si le jeton est invalide ou a été révoqué.


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


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

Voir le post suivant pourquoi et comment le faire.

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


Un jeton d'accès OAuth arbitraire ne peut pas être utilisé pour l'authentification, car la signification du jeton est en dehors de la spécification OAuth Core. Il pourrait être destiné à une fenêtre à usage unique ou à une fenêtre d'expiration étroite, ou fournir un accès que l'utilisateur ne souhaite pas donner. Il est également opaque, et le consommateur OAuth qui l'a obtenu n'a peut-être jamais vu d'identifiant d'utilisateur.

Un fournisseur de services OAuth et un ou plusieurs consommateurs pourraient facilement utiliser OAuth pour fournir un jeton d'authentification vérifiable, et il existe des propositions et des idées pour le faire, mais un fournisseur de services arbitraire parlant uniquement OAuth Core ne peut pas le fournir sans d'autres l'ordination avec un consommateur. La méthode REST AuthSubTokenInfo spécifique à Google, avec l'identifiant de l'utilisateur, est proche, mais elle ne convient pas non plus, car elle pourrait invalider le jeton, ou le jeton pourrait expirer.

Si votre identifiant Google est un identifiant OpenId et que votre «interface publique» est une application Web ou peut appeler le navigateur de l'utilisateur, vous devriez probablement utiliser l'OpenID OP de Google.

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

Une façon de vérifier une authentification précédente par rapport à un identificateur OpenID consiste simplement à effectuer une nouvelle authentification, en supposant que le même agent utilisateur est utilisé. L'OP devrait être capable de renvoyer une assertion positive sans interaction de l'utilisateur (en vérifiant un cookie ou un CERT client, par exemple). L'OP est libre d'exiger une autre interaction de l'utilisateur, et le fera probablement si la demande d'authentification provient d'un autre domaine (mon OP me donne la possibilité de ré-authentifier ce RP particulier sans interagir dans le futur). Et dans le cas de Google, l'interface utilisateur que l'utilisateur a utilisée pour obtenir le jeton OAuth peut ne pas utiliser le même identificateur de session, l'utilisateur devra donc se réauthentifier. Mais dans tous les cas, vous serez en mesure d'affirmer l'identité.


Voici un exemple utilisant Guzzle :

/**
 * @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();
}

Réponse de flux de code oauth Google en plus de access_token renvoie également id_token qui contient des informations utiles pour la validation sous forme cryptée.

Une chose qui rend les jetons d'identification utiles est le fait que vous pouvez les transmettre autour de différents composants de votre application. Ces composants peuvent utiliser un jeton d'identification en tant que mécanisme d'authentification léger authentifiant l'application et l'utilisateur. Mais avant de pouvoir utiliser les informations contenues dans le jeton d'identification ou de s'en prévaloir pour affirmer que l'utilisateur s'est authentifié, vous devez le valider.

La validation d'un jeton d'identification nécessite plusieurs étapes:

  • Vérifiez que le jeton d'identification est un JWT correctement signé avec une clé publique Google appropriée.
  • Vérifiez que la valeur de aud dans le jeton ID est égale à l'ID client de votre application.
  • Vérifiez que la valeur de iss dans le jeton d'ID est égale à accounts.google.com ou https://accounts.google.com .
  • Vérifiez que l'heure d'expiration (exp) du jeton d'identification n'a pas été transmise.
  • Si vous avez transmis un paramètre hd dans la demande, vérifiez que le jeton d'identification possède une revendication hd correspondant à votre domaine hébergé Google Apps.

https://developers.google.com/identity/protocols/OpenIDConnect#validatinganidtoken lien https://developers.google.com/identity/protocols/OpenIDConnect#validatinganidtoken contient des exemples 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 .


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;
    }
}




google-authentication