Se usó la API de Cloud Translation para traducir esta página.

Cómo usar AuthSub en ActionScript

En este documento, se describe cómo usar el sistema de autenticación AuthSub de Google desde una aplicación Flash o Silverlight.

Nota: Si ya conoces AuthSub, el servicio de autenticación de cuentas de Google para aplicaciones basadas en la Web, verás que AuthSub para ActionScript es muy similar desde el punto de vista conceptual. La implementación subyacente es diferente, pero las diferencias no son importantes para ti como desarrollador de aplicaciones cliente. En algunos documentos, en contextos en los que la distinción es irrelevante, nos referimos a AuthSub para ActionScript como "AuthSub".

La interfaz de AuthSub para ActionScript permite que las aplicaciones Flash o Silverlight se autentiquen en feeds protegidos de la API de datos de Google en nombre de un usuario. Para mantener un alto nivel de seguridad, la interfaz permite a la aplicación obtener un token de autenticación sin necesidad de administrar la información de acceso de la cuenta del usuario.

AuthSub para ActionScript es una variante de AuthSub para JavaScript. Al igual que AuthSub para JavaScript, proporciona un método multidominio para que las aplicaciones cliente se autentiquen desde una página web alojada en un dominio ajeno a Google. Se diferencia del AuthSub estándar en que el servicio de autenticación reside en un dominio diferente (accounts.googleapis.com en lugar de www.google.com) y proporciona un archivo crossdomain.xml que permite el acceso a ese dominio desde sitios externos.

Consulta también el Grupo de API de Cuentas de Google para debatir sobre el uso de todas las API del servicio de autenticación.

Público

Este documento está dirigido a programadores que desarrollan aplicaciones web Flash o Silverlight que acceden a servicios de Google.

En este documento, se asume que comprendes las ideas generales detrás del protocolo de API de datos de Google y la interfaz de AuthSub. También se supone que sabes programar en ActionScript.

Entornos compatibles

Actualmente, AuthSub para ActionScript es compatible con Firefox 1.5 y versiones posteriores e Internet Explorer 6.0 y versiones posteriores, con Flash 9.0 o versiones posteriores o Silverlight 2.0 o versiones posteriores.

Cómo funciona AuthSub para ActionScript

Este es un breve resumen de cómo funciona la comunicación entre una aplicación web, el servicio de autenticación de Google y un servicio de datos de Google:

Para acceder a un servicio de datos de Google en nombre de un usuario, la aplicación web debe tener un token de autenticación válido. Por lo general, las aplicaciones almacenan este token en una cookie. Si no existe tal cookie, la aplicación web debe adquirir el token a través de AuthSub. Para adquirir un token, la aplicación web realiza una llamada de acceso de AuthSub para ActionScript al servicio de autenticación y especifica el servicio al que se accederá.
Cuando recibe la solicitud de la aplicación web, el servicio de autenticación redirecciona al usuario a la página "Solicitud de acceso". En esta página, se solicita al usuario que acceda a su cuenta de Google y le solicita que conceda o rechace el acceso a su servicio de Google.
El usuario decide si otorgará o no el acceso a la aplicación web. Si el usuario rechaza el acceso, se lo redirige a una página de Google en lugar de a la aplicación web.
Si el usuario accede y otorga acceso correctamente, el servicio de autenticación redirecciona al usuario de vuelta a la URL de la aplicación web que hizo la llamada original. El redireccionamiento entrega un token de autenticación para el servicio especificado a través de un parámetro de consulta. La aplicación debe almacenar el token como una cookie en el navegador del usuario, en el dominio de la aplicación web. El token es válido hasta que lo revoques. (Consulta la sección Acerca de los tokens para obtener información sobre cuándo revocar los tokens).
La aplicación web se comunica con el servicio de datos de Google y envía el token de autenticación junto con cada solicitud enviada al servicio.
Si el servicio de datos de Google reconoce el token, proporcionará los datos solicitados.

Usa la interfaz de AuthSub para ActionScript

AuthSub para ActionScript, o AuthSubAS, proporciona un extremo AuthSub de dominio cruzado para las aplicaciones Flash (o Silverlight) que usan las API de datos de Google.

AuthSubAS proporciona una duplicación de los extremos de AuthSub que se encuentran en google.com, con un archivo crossdomain.xml adicional que permite que Flash (o Silverlight) acceda a esos extremos. Por ejemplo, el extremo AuthSubSessionToken se puede usar si accedes a https://accounts.googleapis.com/accounts/AuthSubSessionToken.

A continuación, se describe el proceso de obtención de un token de autenticación y su uso para acceder a un servicio de Google desde una aplicación Flash.

Configure las políticas multidominio.

Para usar Flash en varios dominios, se debe inicializar con una política para cada dominio externo al que se acceda. A fin de hacerlo, invoca el método Security.loadPolicyFile(policy) de ActionScript para cada dominio de la siguiente manera:

<?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');
    }

Ver muestra completa

Ten en cuenta que, aquí, cargamos la política para accounts.googleapis.com (AuthSubAS) y para photos.googleapis.com/data (PicasaWeb, al que accede el ejemplo más adelante).

Solicita un token de un solo uso.
El primer paso del proceso de AuthSub es solicitar un token de un solo uso al extremo de AuthSub. Para ello, tu aplicación debe invocar una llamada al extremo AuthSubRequest de la siguiente manera:
```
      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');
```
Ver muestra completa

Este método requiere un valor de scope. Cada servicio de Google define el alcance del acceso que permite, y debes hacer referencia a ese alcance en la solicitud de token. Para determinar qué valor de alcance usar, revisa la documentación del servicio de Google al que quieres acceder. El alcance se parece a una URL: puede ser una simple URL que identifica el servicio o podría especificar un acceso más restringido, como limitar el acceso a solo lectura. Cuando el servicio ofrece una variedad de alcances, solicita el token con el alcance más estricto posible. Por ejemplo, para acceder a los feeds de datos de Calendario de Google, usa el alcance 'http://www.google.com/calendar/feeds', no 'http://www.google.com/calendar'.

Sugerencias:
- Le recomendamos encarecidamente que proporcione un botón u otro mecanismo de entrada del usuario para solicitarle que inicie el proceso de acceso manualmente. En cambio, si revisas y redireccionas al usuario inmediatamente después de cargarlo, sin esperar a que el usuario interactúe con él, lo primero que verá el usuario cuando llegue a tu página será la página de acceso de Google. Si el usuario decide no acceder, entonces Google no lo dirige de vuelta a tu página; por lo tanto, desde el punto de vista del usuario, intentó visitar tu página, pero fue enviado sin respuesta. Esta situación puede resultar confusa y frustrante para los usuarios.
- Las aplicaciones que necesitan acceder a más de un servicio de Google para un usuario deben solicitar un token nuevo para cada servicio nuevo (porque cada servicio tiene un alcance diferente).

Solicita un token de autenticación.

El extremo AuthSubRequest mostrará un token de un solo uso a tu aplicación configurando la URL del navegador del usuario en http://yourWebAppUrl?token=singleUseToken. Una vez que la aplicación reciba el token de un solo uso, deberá intercambiarlo por un token de uso múltiple (de larga duración), que luego se puede usar para realizar solicitudes a los feeds de datos de Google. Para ello, llama al método AuthSubSessionToken con el token de uso único.

Tu aplicación debe verificar el parámetro token en la URL cuando se cargue:

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

Ver muestra completa

Si se encuentra el token, debería llamar a un método como getLongLivedToken, que invoca el extremo 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);
      }

Ver muestra completa

Un método como el controlador onGetTokenResult debe guardar el token que se muestra:

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

Ver muestra completa

Sugerencias:

Recomendamos encarecidamente que tu aplicación almacene el token a largo plazo en una cookie y que las verifique antes de la verificación a corto plazo. Esto evita que los usuarios tengan que visitar la página de confirmación de AuthSub cada vez que deseen usar tu aplicación.

Usa un token de autenticación.

Para usar el token de autenticación, conéctalo a través de un encabezado Authorization a cualquier solicitud realizada a un servicio de Google:

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

Ejemplo en ActionScript para el servicio Fotos:

      // 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'));

Ver muestra completa

Google recomienda proporcionar una función de salida manual, como un botón de cierre de sesión o un vínculo en el que se pueda hacer clic. Ese enfoque les da a los usuarios la opción de salir cuando deseen, o bien mantener el acceso y mantener sus feeds de datos convenientemente disponibles la próxima vez que accedan a su aplicación.

Acerca de los tokens

En esta sección, se describen los tokens que utiliza AuthSub para ActionScript. En la mayoría de los contextos, no necesitarás conocer esta información.

Cada token de autenticación es específico para los siguientes datos:

Alcance del servicio de Google
Cuenta de Google del usuario
Aplicación cliente

Los datos del token garantizan que solo la aplicación de terceros especificada pueda solicitar datos y que la solicitud esté limitada a los datos del alcance y de la cuenta de usuario especificados.

Solo un token para esta combinación de alcance, usuario y cliente puede ser válido a la vez. Una aplicación web debe solicitar un token nuevo cada vez que necesite acceder a un nuevo servicio de Google para un usuario determinado. El alcance del acceso que cubre el token depende del servicio de Google, que puede optar por limitar el acceso a ciertos tipos de datos o actividades, como el acceso de solo lectura.

El token que muestra la interfaz de AuthSub para ActionScript se puede usar tantas veces como sea necesario hasta que se revoque. Depende de su aplicación administrar la vida útil del token, equilibrando la seguridad con la comodidad. Google recomienda solicitar un token nuevo cada vez que se inicia una sesión nueva.

Algunos servicios de Google pueden permitir el acceso solo a aplicaciones web que estén registradas y usen tokens seguros. No se admite AuthSub para ActionScript. Para usar tokens seguros, su organización debe registrar un certificado SSL con Google y firmar todas las solicitudes de esos feeds de datos.

Volver al principio