Cette page a été traduite par l'API Cloud Translation.

Utiliser AuthSub dans ActionScript

Ce document explique comment utiliser le système d'authentification AuthSub de Google à partir d'une application Flash ou Silverlight.

Remarque : Si vous connaissez déjà AuthSub, le service d'authentification de compte pour les applications Web de Google, vous constaterez qu'AuthSub pour ActionScript est très similaire. La mise en œuvre sous-jacente est différente, mais les différences ne sont pas importantes pour vous en tant que développeur d'applications clientes. Dans certaines parties de la documentation, dans le cas où la distinction n'est pas pertinente, nous faisons référence à AuthSub pour ActionScript sous le nom de "AuthSub".

L'interface AuthSub pour ActionScript permet aux applications Flash ou Silverlight de s'authentifier auprès des flux Google Data API protégés au nom d'un utilisateur. Afin de maintenir un niveau de sécurité élevé, l'interface permet à l'application d'obtenir un jeton d'authentification sans gérer les informations de connexion du compte de l'utilisateur.

AuthSub pour ActionScript est une variante d'AuthSub pour JavaScript. Tout comme AuthSub pour JavaScript, cette méthode permet aux applications clientes de s'authentifier à partir d'une page Web hébergée sur un domaine autre que Google. La différence avec AuthSub est que le service d'authentification réside sur un autre domaine (accounts.googleapis.com au lieu de www.google.com) et fournit un fichier crossdomain.xml qui permet d'accéder à ce domaine depuis des sites externes.

Pour en savoir plus sur l'utilisation de toutes les API du service Authentication, consultez le groupe dédié aux comptes Google.

Audience

Ce document est destiné aux programmeurs qui développent des applications Web Flash ou Silverlight qui accèdent aux services Google.

Dans ce document, nous partons du principe que vous comprenez les principes généraux du protocole Google Data APIs et de l'interface AuthSub. Nous supposons également que vous savez programmer dans ActionScript.

Environnements compatibles

AuthSub pour ActionScript est actuellement compatible avec Firefox 1.5 (et versions ultérieures) et Internet Explorer 6.0 (et versions ultérieures), avec Flash 9.0 (ou versions ultérieures) et Silverlight 2.0 (ou versions ultérieures).

Fonctionnement d'AuthSub pour ActionScript

Voici un bref récapitulatif du fonctionnement de la communication entre une application Web, le service d'authentification Google et un service de données Google:

Pour accéder à un service de données Google au nom d'un utilisateur, l'application Web doit disposer d'un jeton d'authentification valide. En règle générale, les applications stockent ce jeton dans un cookie. Si ce cookie n'existe pas, l'application Web doit acquérir le jeton via AuthSub. Pour obtenir un jeton, l'application Web effectue un appel de connexion AuthSub pour ActionScript auprès du service d'authentification, en spécifiant le service auquel accéder.
À la réception de la requête de l'application Web, le service d'authentification redirige l'utilisateur vers une page "Demande d'accès". Cette page invite l'utilisateur à se connecter à son compte Google et lui demande d'accorder ou de refuser l'accès à son service Google.
L'utilisateur décide d'accorder ou de refuser l'accès à l'application Web. Si l'utilisateur refuse l'accès, il est redirigé vers une page Google plutôt que vers l'application Web.
Si l'utilisateur parvient à se connecter et à autoriser l'accès, le service d'authentification le redirige vers l'URL de l'application Web qui a effectué l'appel d'origine. La redirection fournit un jeton d'authentification pour le service spécifié via un paramètre de requête. L'application doit stocker le jeton en tant que cookie dans le navigateur de l'utilisateur, sous le domaine de l'application Web. Le jeton reste valide jusqu'à ce qu'il soit révoqué. (Consultez la section À propos des jetons pour savoir quand révoquer des jetons.)
L'application Web contacte le service de données Google et envoie le jeton d'authentification avec chaque requête envoyée au service.
Si le service Google Data reconnaît le jeton, il fournit les données demandées.

Utiliser l'interface AuthSub pour ActionScript

AuthSub pour ActionScript, ou AuthSubAS, fournit un point de terminaison AuthSub sur plusieurs domaines pour les applications Flash (ou Silverlight) utilisant les API Google Data.

AuthSubAS fournit un miroir des points de terminaison AuthSub trouvés sur google.com, avec un fichier crossdomain.xml supplémentaire qui permet à Flash (ou Silverlight) d'accéder à ces points de terminaison. Par exemple, vous pouvez utiliser le point de terminaison AuthSubSessionToken en accédant à https://accounts.googleapis.com/accounts/AuthSubSessionToken.

Les étapes suivantes décrivent comment obtenir un jeton d'authentification et l'utiliser pour accéder à un service Google à partir d'une application Flash.

Configurez les règles interdomaines.

Pour utiliser Flash dans plusieurs domaines, il doit être initialisé avec une règle pour chaque domaine externe accessible. Pour ce faire, appelez la méthode ActionScript Security.loadPolicyFile(policy) pour chaque domaine, comme suit:

<?xml version="1.0" encoding="utf-8"?>
<Application xmlns="http://www.adobe.com/2006/mxml"
  initialize="onInitialized()"
  applicationComplete="onLoaded()">
  <Script>
    import flash.external.ExternalInterface;
    import flash.net.navigateToURL;
    import mx.controls.Alert;

    private function onInitialized() : void {
      // Load the cross domain policy file for each of the googleapis.com
      // domains used. At the very least, we need the ones for the API (photos,
      // in this case) and the one for AuthSub for ActionScript (accounts).
      Security.loadPolicyFile('http://photos.googleapis.com/data/crossdomain.xml');
      Security.loadPolicyFile('https://accounts.googleapis.com/crossdomain.xml');
    }

Afficher l'intégralité de l'exemple

Notez que nous chargeons ici la stratégie pour accounts.googleapis.com (AuthSubAS) et pour photos.googleapis.com/data (PicasaWeb, auquel l'exemple accède ultérieurement).

Demandez un jeton à usage unique.
La première étape du processus AuthSub consiste à demander un jeton à usage unique au point de terminaison AuthSub. Pour ce faire, votre application doit appeler un point de terminaison vers AuthSubRequest, comme suit:
```
      var getTokenPage : URLRequest = new URLRequest('https://www.google.com/accounts/AuthSubRequest');

      // Construct the parameters of the AuthSub request. These are the same parameters
      // as normal AuthSub, which can be found here: /accounts/docs/AuthSub.html#AuthSubRequest
      var authSubParams : URLVariables = new URLVariables();
      authSubParams['scope'] = 'http://photos.googleapis.com/data'; // photos API
      authSubParams['session'] = 1; // single-use token
      authSubParams['secure'] = 0; // non-secure apps
      authSubParams['next'] = 'photos.swf'; // The URL of this app.

      getTokenPage.data =  authSubParams;
      navigateToURL(getTokenPage, '_top');
```
Afficher l'intégralité de l'exemple

Cette méthode nécessite une valeur scope. Chaque service Google définit le champ d'application de l'accès qu'il autorise, et vous devez référencer ce champ d'application dans la requête de jeton. Pour déterminer la valeur de champ d'application à utiliser, consultez la documentation du service Google auquel vous souhaitez accéder. Le champ d'application ressemble à une URL : il peut s'agir d'une URL simple identifiant le service ou d'un accès plus limité, tel que la restriction d'accès en lecture seule. Lorsque le service offre le choix de champs d'application, demandez le jeton dont le champ d'application est le plus restreint possible. Par exemple, pour accéder aux flux de données de Google Agenda, utilisez le champ d'application 'http://www.google.com/calendar/feeds', et non 'http://www.google.com/calendar'.

Astuces :
- Nous vous recommandons vivement de fournir un bouton de connexion ou tout autre mécanisme de saisie pour inviter l'utilisateur à démarrer le processus de connexion manuellement. En revanche, si vous effectuez une vérification et une redirection immédiatement après le chargement, sans attendre l'interaction de l'utilisateur, la première chose que cet utilisateur voit à son arrivée sur votre page est une page de connexion Google. Si l'internaute décide de ne pas se connecter, Google ne le redirige pas vers votre page. C'est pourquoi, du point de vue de l'utilisateur, il tente de visiter votre page, mais est exclu de son site et n'est jamais renvoyé. Ce scénario peut être déroutant et frustrant pour les utilisateurs.
- Les applications devant accéder à plusieurs services Google pour un utilisateur doivent demander un nouveau jeton pour chaque nouveau service (car chaque service a un champ d'application différent).

Demandez un jeton d'authentification.

Le point de terminaison AuthSubRequest renvoie un jeton à usage unique à votre application en définissant l'URL du navigateur de l'utilisateur sur http://yourWebAppUrl?token=singleUseToken. Une fois que l'application a reçu son jeton à usage unique, celui-ci doit être échangé contre un jeton à usages multiples (longue durée), qui peut ensuite être utilisé pour envoyer des requêtes aux flux de données Google. Pour ce faire, appelez la méthode AuthSubSessionToken avec le jeton à utilisation unique.

Votre application doit vérifier le paramètre token dans l'URL lors du chargement:

    private function onLoaded() : void {

      // Once the application has loaded, check to see if an AuthSub token was
      // placed into the current page's URL. If it was, the user has already
      // authenticated, and we can continue to connect to the the service itself.
      var searchPortion : String = ExternalInterface.call('window.location.search.toString');

      if (searchPortion.length > 0) {
         // remove the ? from the token and extract the token.
         searchPortion = searchPortion.substring(1);

         // NOTE: Real applications should parse the URL properly.
         if (searchPortion.indexOf('token=') == 0) {
           getLongLivedToken(searchPortion.substring(6));
           return;
         }

      // more code
      ...
    }

Afficher l'intégralité de l'exemple

Si le jeton est trouvé, il doit appeler une méthode telle que getLongLivedToken, qui appelle le point de terminaison AuthSubSessionToken:

    private function getLongLivedToken(singleUseToken : String) : void {
      // Construct a call to the AuthSub for ActionScript endpoint on accounts.googleapis.com.
      // This call will exchange the single use token given to use by AuthSub for a long-term
      // token that we can use to make requests to endpoints such as Photos.
      var getTokenRequest : URLRequest = new URLRequest('https://accounts.googleapis.com/accounts/AuthSubSessionToken');

      // Due to a bug in Flash, a URLRequest with a GET request will
      // not properly send headers. We therefore use POST for this and *ALL*
      // requests.
      getTokenRequest.method = URLRequestMethod.POST;

      // Due to a bug in Flash, a URLRequest without a valid parameter will
      // not properly send headers. We therefore add a useless parameter to
      // make this code work.
      getTokenRequest.data = new URLVariables('pleaseignore=ignore');

      // Add the AuthSub for ActionScript headers.
      getTokenRequest.requestHeaders.push(new URLRequestHeader('Authorization', 'AuthSub token="' + singleUseToken + '"'));

      // Create the loader to get the token itself. The loader will callback
      // to the following event handlers if and when the server responds.
      var getToken : URLLoader = new URLLoader();
      getToken.addEventListener(Event.COMPLETE, onGetTokenResult);
      getToken.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onGetTokenFailed);
      getToken.addEventListener(IOErrorEvent.IO_ERROR, onGetTokenFailed);

      try {
        getToken.load(getTokenRequest);
      } catch (e : Error) {
        Alert.show('Some error occurred: ' + e);
      }

Afficher l'intégralité de l'exemple

Une méthode telle que le gestionnaire onGetTokenResult doit enregistrer le jeton renvoyé:

    private function onGetTokenResult(e : Event) : void {
      // Load the parameters from the response.
      var getToken : URLLoader = URLLoader(e.target);
      var params : URLVariables = new URLVariables(getToken.data);

      // Parse the session token from the result. Real applications
      // might at this point store the token in a long-term cookie so
      // that repeated usages of the application do not require this entire
      // authentication process.
      sessionToken = params.Token;

      // Trim the newline from the end of the session token.
      sessionToken = sessionToken.substring(0, sessionToken.length - 1);
   }

Afficher l'intégralité de l'exemple

Astuces :

Nous recommandons vivement à votre application de stocker le jeton long terme dans un cookie et de le vérifier avant la vérification du jeton à court terme. Ainsi, les utilisateurs n'auront pas à accéder à la page de confirmation AuthSub chaque fois qu'ils souhaiteront utiliser votre application.

Utiliser un jeton d'authentification.

Pour utiliser le jeton d'authentification, associez-le à un service Google via un en-tête Authorization:

Authorization: AuthSub token="(session token goes here)"

Exemple dans ActionScript pour le service Photos:

      // Prepare a request to the photos API for the private album
      // of the user.
      var albumRequest : URLRequest = new URLRequest('http://photos.googleapis.com/data/feed/api/user/default');
      albumRequest.data = new URLVariables('access=private&v=2&err=xml');

      // Due to a bug in Flash, a URLRequest with a GET request will
      // not properly send headers. We therefore use POST for this and *ALL*
      // requests.
      albumRequest.method = URLRequestMethod.POST;

      var authsubHeader : String = 'AuthSub token="' + sessionToken + '"';

      // Add the Authorization header which uses the session token.
      albumRequest.requestHeaders.push(new URLRequestHeader('Authorization', authsubHeader));

      // The X-HTTP-Method-Override header tells the Photos API to treat this request
      // as a GET request, even though it is being conducted as a POST (due to the bug
      // mentioned above). This is very important, as GData APIs will react differently
      // to different HTTP request types.
      albumRequest.requestHeaders.push(new URLRequestHeader('X-HTTP-Method-Override', 'GET'));

      // We expect ATOM XML to be returned.
      albumRequest.requestHeaders.push(new URLRequestHeader('Content-Type', 'application/atom+xml'));

Afficher l'intégralité de l'exemple

Google recommande de fournir une fonctionnalité de déconnexion manuelle, comme un bouton de déconnexion ou un lien cliquable. Cette approche permet aux utilisateurs de se déconnecter quand ils le souhaitent ou de rester connectés et de maintenir facilement leurs flux de données accessibles la prochaine fois qu'ils accèdent à votre application.

À propos des jetons

Cette section décrit les jetons utilisés par AuthSub pour ActionScript. Dans la plupart des cas, vous n'avez pas besoin de connaître ces informations.

Chaque jeton d'authentification est spécifique aux données suivantes:

Portée des services Google
Compte Google de l'utilisateur
Application cliente

Les données du jeton garantissent que seule l'application tierce spécifiée peut demander des données, et que la demande est limitée aux données du champ d'application et du compte utilisateur spécifiés.

Un seul jeton pour cette combinaison champ d'application, utilisateur et client peut être valide à la fois. Une application Web doit demander un nouveau jeton chaque fois qu'elle a besoin d'accéder à un nouveau service Google pour un utilisateur donné. Le champ d'application de l'accès dépend du service Google, qui peut choisir de limiter l'accès à certains types de données ou d'activités, comme l'accès en lecture seule.

Le jeton renvoyé par l'interface AuthSub pour ActionScript peut être utilisé autant de fois que nécessaire jusqu'à ce qu'il soit révoqué. C'est à votre application de gérer la durée de vie du jeton, en assurant la sécurité et le confort. Google recommande de demander un nouveau jeton chaque fois qu'une nouvelle session est lancée.

Certains services Google n'autorisent l'accès qu'aux applications Web enregistrées et utilisant des jetons sécurisés. AuthSub pour ActionScript n'est pas compatible avec ces services. Pour utiliser des jetons sécurisés, votre organisation doit enregistrer un certificat SSL auprès de Google et signer toutes les requêtes liées à ces flux de données.

Haut de page