Uso de AuthSub en ActionScript

En este documento, se describe cómo usar el sistema de autenticación AuthSub de Google desde una aplicación de 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 conceptualmente muy similar. La implementación subyacente es diferente, pero las diferencias no son importantes para ti como desarrollador de aplicaciones cliente. En parte de la documentación, en contextos en los que la distinción es irrelevante, nos referimos a AuthSub para ActionScript como "AuthSub" para abreviar.

La interfaz de AuthSub para ActionScript permite que las aplicaciones de Flash o Silverlight se autentiquen en los feeds protegidos de las APIs de Google Data en nombre de un usuario. Para mantener un alto nivel de seguridad, la interfaz permite que la aplicación obtenga un token de autenticación sin tener que controlar la información de acceso a la cuenta del usuario.

AuthSub para ActionScript es una variante de AuthSub para JavaScript. Al igual que AuthSub para JavaScript, proporciona un método entre dominios para que las aplicaciones cliente se autentiquen desde una página web alojada en un dominio que no es de 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 la API de Cuentas de Google para obtener información sobre el uso de todas las APIs del servicio de autenticación.

Público

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

En este documento, se supone que comprendes las ideas generales detrás del protocolo de las APIs de Google Data 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 y versiones posteriores, o Silverlight 2.0 y versiones posteriores.

Cómo funciona AuthSub para ActionScript

A continuación, se incluye un resumen rápido 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 Google Data 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 inicio de sesión de AuthSub para ActionScript al servicio de autenticación, especificando el servicio al que se accederá.
Cuando recibe la solicitud de la aplicación web, el servicio de autenticación redirecciona al usuario a una página de "Solicitud de acceso". En esta página, se le solicita al usuario que acceda a su Cuenta de Google y que otorgue o rechace el acceso a su servicio de Google.
El usuario decide si otorga o deniega el acceso a la aplicación web. Si el usuario rechaza el acceso, se lo dirige a una página de Google en lugar de volver a la aplicación web.
Si el usuario accede correctamente y otorga acceso, el servicio de autenticación lo redirecciona a la URL de la aplicación web que realizó la llamada original. El redireccionamiento entrega un token de autenticación para el servicio especificado a través de un parámetro de búsqueda. 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 se revoca. (Consulta la sección Acerca de los tokens para obtener consejos sobre cuándo revocarlos).
La aplicación web se comunica con el servicio de datos de Google y envía el token de autenticación con cada solicitud que se envía al servicio.
Si el servicio de datos de Google reconoce el token, proporciona los datos solicitados.

Uso de la interfaz de AuthSub para ActionScript

AuthSub para ActionScript, o AuthSubAS, proporciona un extremo de AuthSub entre dominios para las aplicaciones de Flash (o Silverlight) que usan las APIs de Google Data.

AuthSubAS proporciona un duplicado 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, se puede acceder al extremo AuthSubSessionToken a través de https://accounts.googleapis.com/accounts/AuthSubSessionToken.

En los siguientes pasos, se explica el proceso para obtener un token de autenticación y usarlo para acceder a un servicio de Google desde una aplicación de Flash.

Configura las políticas multidominio.

Para usar Flash de forma entre dominios, se debe inicializar con una política para cada dominio externo al que se accederá. Para ello, invoca el método ActionScript Security.loadPolicyFile(policy) 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 la 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 el ejemplo accede más adelante).

Solicita un token de un solo uso.
El primer paso en el proceso de AuthSub es solicitar un token de un solo uso al extremo de AuthSub. Tu aplicación debe hacerlo invocando 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 la muestra completa

Este método requiere un valor de alcance. 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, consulta la documentación del servicio de Google al que deseas acceder. El alcance se parece a una URL. Puede ser una URL simple que identifica el servicio o puede especificar un acceso más restringido, como limitar el acceso a solo lectura. Cuando el servicio ofrezca una opción de alcances, solicita el token con el alcance más restringido 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:
- Te recomendamos que proporciones un botón de acceso o algún otro mecanismo de entrada del usuario para solicitarle que inicie el proceso de acceso de forma manual. Si, en cambio, verificas y redireccionas inmediatamente después de la carga, sin esperar la interacción del usuario, lo primero que verá el usuario al llegar a tu página será una página de acceso de Google. Si el usuario decide no acceder, Google no lo redirecciona a tu página. Por lo tanto, desde el punto de vista del usuario, intentó visitar tu página, pero se lo envió a otra y nunca se lo redireccionó. Esta situación puede ser 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 devolverá 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 tu aplicación haya recibido el token de un solo uso, debe 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 un solo uso.

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

    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 la muestra completa

Si se encuentra el token, se debe 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 la muestra completa

Un método como el controlador onGetTokenResult debería guardar el token que se devolvió:

    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 la muestra completa

Sugerencias:

Te recomendamos que tu aplicación almacene el token de largo plazo en una cookie y que los verifique antes de verificar el token de corto plazo. Esto evita que los usuarios tengan que visitar la página de confirmación de AuthSub cada vez que quieran usar tu aplicación.

Usa un token de autenticación.

Para usar el token de autenticación, adjúntalo a través de un encabezado Authorization a cualquier solicitud que se realice a un servicio de Google:

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

Ejemplo en ActionScript para el servicio de 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'));

Ver la muestra completa

Google recomienda proporcionar una función de cierre de sesión manual, como un botón de cierre de sesión o un vínculo en el que se pueda hacer clic. Este enfoque les brinda a los usuarios la opción de salir de su cuenta cuando lo deseen o de permanecer conectados y mantener sus feeds de datos disponibles de forma conveniente para la próxima vez que accedan a tu 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:

Permiso 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 se limite a los datos del permiso y la cuenta de usuario especificados.

Solo puede ser válido un token para esta combinación de alcance, usuario y cliente en un momento determinado. Una aplicación web debe solicitar un token nuevo cada vez que necesite acceder a un servicio de Google nuevo para un usuario determinado. El alcance del acceso que abarca 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 devuelve la interfaz de AuthSub para ActionScript se puede usar tantas veces como sea necesario hasta que se revoque. Tu aplicación es la encargada de administrar la vida útil del token, equilibrando la seguridad con la comodidad. Google recomienda solicitar un token nuevo cada vez que se inicie una sesión nueva.

Es posible que algunos servicios de Google solo permitan el acceso a través de aplicaciones web registradas que usen tokens seguros. AuthSub para ActionScript no es compatible con estos servicios. Para usar tokens seguros, tu organización debe registrar un certificado SSL en Google y firmar todas las solicitudes de esos feeds de datos.

Volver al principio

Uso de AuthSub en ActionScript Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Público

Entornos compatibles

Cómo funciona AuthSub para ActionScript

Uso de la interfaz de AuthSub para ActionScript

Acerca de los tokens

Uso de AuthSub en ActionScript