AuthSub in ActionScript verwenden

In diesem Dokument wird beschrieben, wie Sie das AuthSub-Authentifizierungssystem von Google in einer Flash- oder Silverlight-Anwendung verwenden.

Hinweis: Wenn Sie bereits mit AuthSub, dem Google-Dienst zur Kontoauthentifizierung für webbasierte Anwendungen, vertraut sind, werden Sie feststellen, dass AuthSub für ActionScript konzeptionell sehr ähnlich ist. Die zugrunde liegende Implementierung ist unterschiedlich, aber die Unterschiede sind für Sie als Entwickler von Clientanwendungen nicht wichtig. In einigen Dokumentationen wird AuthSub für ActionScript in Kontexten, in denen die Unterscheidung irrelevant ist, kurz als „AuthSub“ bezeichnet.

Mit der AuthSub-Schnittstelle für ActionScript können sich Flash- oder Silverlight-Anwendungen im Namen eines Nutzers bei geschützten Google Data API-Feeds authentifizieren. Um ein hohes Maß an Sicherheit zu gewährleisten, kann die Anwendung über die Schnittstelle ein Authentifizierungstoken abrufen, ohne jemals die Anmeldedaten des Nutzerkontos zu verarbeiten.

AuthSub für ActionScript ist eine Variante von AuthSub für JavaScript. Wie AuthSub für JavaScript bietet es eine domänenübergreifende Methode für Clientanwendungen, sich über eine Webseite zu authentifizieren, die auf einer Nicht-Google-Domain gehostet wird. Sie unterscheidet sich vom Standard-AuthSub dadurch, dass sich der Authentifizierungsdienst in einer anderen Domain befindet (accounts.googleapis.com anstelle von www.google.com) und eine crossdomain.xml-Datei bereitstellt, die den Zugriff auf diese Domain von externen Websites aus ermöglicht.

Weitere Informationen zur Verwendung aller APIs des Authentifizierungsdienstes finden Sie auch in der Google Accounts API Group.

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Flash- oder Silverlight-Webanwendungen entwickeln, die auf Google-Dienste zugreifen.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten des Google Data APIs-Protokolls und der AuthSub-Schnittstelle vertraut sind. Außerdem wird davon ausgegangen, dass Sie in ActionScript programmieren können.

Unterstützte Umgebungen

AuthSub für ActionScript wird derzeit in Firefox 1.5 und höher sowie in Internet Explorer 6.0 und höher mit Flash 9.0 oder höher oder Silverlight 2.0 oder höher unterstützt.

Funktionsweise von AuthSub für ActionScript

Hier finden Sie eine kurze Zusammenfassung der Kommunikation zwischen einer Webanwendung, dem Google-Authentifizierungsdienst und einem Google-Datendienst:

  1. Um im Namen eines Nutzers auf einen Google-Datendienst zuzugreifen, muss die Webanwendung ein gültiges Authentifizierungstoken haben. Normalerweise speichern Anwendungen dieses Token in einem Cookie. Wenn kein solches Cookie vorhanden ist, muss die Webanwendung das Token über AuthSub abrufen. Um ein Token zu erhalten, führt die Webanwendung einen AuthSub-Anmeldeaufruf für ActionScript an den Authentifizierungsdienst aus und gibt den Dienst an, auf den zugegriffen werden soll.
  2. Nachdem der Authentifizierungsdienst die Anfrage von der Webanwendung erhalten hat, leitet er den Nutzer zu einer Seite für den Zugriff auf Anfragen weiter. Auf dieser Seite wird der Nutzer aufgefordert, sich in seinem Google-Konto anzumelden, und er wird gefragt, ob er den Zugriff auf seinen Google-Dienst gewähren oder verweigern möchte.
  3. Der Nutzer entscheidet, ob er den Zugriff auf die Webanwendung gewährt oder verweigert. Wenn der Nutzer den Zugriff verweigert, wird er auf eine Google-Seite weitergeleitet und nicht zurück zur Webanwendung.
  4. Wenn sich der Nutzer erfolgreich anmeldet und Zugriff gewährt, leitet der Authentifizierungsdienst den Nutzer zurück zur Webanwendungs-URL, von der der ursprüngliche Aufruf erfolgte. Bei der Weiterleitung wird ein Authentifizierungstoken für den angegebenen Dienst über einen Abfrageparameter bereitgestellt. Die Anwendung sollte das Token als Cookie im Browser des Nutzers unter der Domain der Webanwendung speichern. Das Token ist bis zum Widerruf gültig. Im Abschnitt Informationen zu Tokens finden Sie Hinweise dazu, wann Tokens widerrufen werden sollten.
  5. Die Webanwendung kontaktiert den Google-Datendienst und sendet das Authentifizierungstoken zusammen mit jeder Anfrage, die an den Dienst gesendet wird.
  6. Wenn der Google-Datendienst das Token erkennt, werden die angeforderten Daten bereitgestellt.

AuthSub für ActionScript-Schnittstelle verwenden

AuthSub für ActionScript oder AuthSubAS bietet einen domänenübergreifenden AuthSub-Endpunkt für Flash- (oder Silverlight-)Anwendungen, die Google Data APIs verwenden.

AuthSubAS bietet eine Spiegelung der AuthSub-Endpunkte auf google.com mit einer zusätzlichen crossdomain.xml-Datei, die Flash (oder Silverlight) den Zugriff auf diese Endpunkte ermöglicht. Der Endpunkt AuthSubSessionToken kann beispielsweise über https://accounts.googleapis.com/accounts/AuthSubSessionToken aufgerufen werden.

In den folgenden Schritten wird beschrieben, wie Sie ein Authentifizierungstoken abrufen und damit über eine Flash-Anwendung auf einen Google-Dienst zugreifen.

  1. Domainübergreifende Richtlinien einrichten

    Wenn Sie Flash domainübergreifend verwenden möchten, muss es für jede externe Domain, auf die zugegriffen werden soll, mit einer Richtlinie initialisiert werden. Rufen Sie dazu die ActionScript-Methode Security.loadPolicyFile(policy) für jede Domain auf:

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

    Vollständiges Beispiel ansehen

    Hier wird die Richtlinie für accounts.googleapis.com (AuthSubAS) und für photos.googleapis.com/data (PicasaWeb, auf das im Beispiel später zugegriffen wird) geladen.

  2. Einmal-Token anfordern

    Im ersten Schritt des AuthSub-Prozesses wird ein Einmal-Token vom AuthSub-Endpunkt angefordert. Ihre Anwendung sollte dazu den AuthSubRequest-Endpunkt aufrufen, etwa so:

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

    Vollständiges Beispiel ansehen

    Für diese Methode ist ein scope-Wert erforderlich. Jeder Google-Dienst definiert den Umfang des Zugriffs, den er zulässt. Sie müssen diesen Umfang in der Tokenanfrage angeben. Welchen Bereichswert Sie verwenden müssen, erfahren Sie in der Dokumentation für den Google-Dienst, auf den Sie zugreifen möchten. Der Bereich sieht wie eine URL aus. Es kann sich um eine einfache URL handeln, die den Dienst identifiziert, oder es kann ein eingeschränkterer Zugriff angegeben werden, z. B. nur Lesezugriff. Wenn der Dienst eine Auswahl an Bereichen bietet, fordern Sie das Token mit dem engsten Bereich an. Wenn Sie beispielsweise auf die Datenfeeds von Google Kalender zugreifen möchten, verwenden Sie den Bereich 'http://www.google.com/calendar/feeds' und nicht 'http://www.google.com/calendar'.

    Tipps:

    • Wir empfehlen dringend, eine Anmeldeschaltfläche oder einen anderen Mechanismus zur Nutzereingabe bereitzustellen, um den Nutzer aufzufordern, den Anmeldevorgang manuell zu starten. Wenn Sie stattdessen sofort nach dem Laden prüfen und weiterleiten, ohne auf eine Nutzerinteraktion zu warten, sieht der Nutzer als Erstes eine Google-Anmeldeseite, wenn er auf Ihre Seite gelangt. Wenn sich der Nutzer nicht anmeldet, leitet Google ihn nicht zurück auf Ihre Seite. Aus Nutzersicht hat er also versucht, Ihre Seite aufzurufen, wurde aber weggeleitet und nie zurückgeschickt. Dieses Szenario kann für Nutzer verwirrend und frustrierend sein.
    • Anwendungen, die für einen Nutzer auf mehr als einen Google-Dienst zugreifen müssen, müssen für jeden neuen Dienst ein neues Token anfordern, da jeder Dienst einen anderen Bereich hat.

  3. Authentifizierungstoken anfordern

    Der AuthSubRequest-Endpunkt gibt ein Einmal-Token an Ihre Anwendung zurück, indem er die URL des Nutzerbrowsers auf http://yourWebAppUrl?token=singleUseToken festlegt. Sobald Ihre Anwendung das Einmaltoken erhalten hat, muss sie es gegen ein Mehrfachnutzungstoken (mit langer Gültigkeitsdauer) eintauschen, das dann für Anfragen an Google-Datenfeeds verwendet werden kann. Rufen Sie dazu die Methode AuthSubSessionToken mit dem Einmal-Token auf.

    Ihre Anwendung sollte beim Laden der URL nach dem Parameter token suchen:

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

    Vollständiges Beispiel ansehen

    Wenn das Token gefunden wird, sollte eine Methode wie getLongLivedToken aufgerufen werden, die den AuthSubSessionToken-Endpunkt aufruft:

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

    Vollständiges Beispiel ansehen

    Eine Methode wie der onGetTokenResult-Handler sollte das zurückgegebene Token speichern:

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

    Vollständiges Beispiel ansehen

    Tipps:

    • Wir empfehlen dringend, dass Ihre Anwendung das Langzeit-Token in einem Cookie speichert und es vor der Prüfung des Kurzzeit-Tokens prüft. So wird verhindert, dass Nutzer die AuthSub-Bestätigungsseite jedes Mal aufrufen müssen, wenn sie Ihre Anwendung verwenden möchten.

  4. Authentifizierungstoken verwenden

    Wenn Sie das Authentifizierungstoken verwenden möchten, hängen Sie es über einen Authorization-Header an alle Anfragen an einen Google-Dienst an:

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

    Beispiel in ActionScript für den Fotos-Dienst:

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

    Vollständiges Beispiel ansehen

    5. Google empfiehlt, eine Funktion für die manuelle Abmeldung anzubieten, z. B. eine Schaltfläche oder einen anklickbaren Link. So haben Nutzer die Möglichkeit, sich abzumelden, wann immer sie möchten, oder angemeldet zu bleiben und ihre Datenfeeds bequem für den nächsten Zugriff auf Ihre Anwendung verfügbar zu halten.

Tokens

In diesem Abschnitt werden die von AuthSub für ActionScript verwendeten Tokens beschrieben. In den meisten Fällen müssen Sie diese Informationen nicht kennen.

Jedes Authentifizierungstoken ist für die folgenden Daten spezifisch:

  • Google-Dienstbereich
  • Google-Konto des Nutzers
  • Clientanwendung

Die Tokendaten sorgen dafür, dass nur die angegebene Drittanbieteranwendung Daten anfordern kann und dass die Anfrage auf Daten aus dem angegebenen Bereich und Nutzerkonto beschränkt ist.

Für diese Kombination aus Bereich, Nutzer und Client kann jeweils nur ein Token gültig sein. Eine Webanwendung muss jedes Mal ein neues Token anfordern, wenn sie für einen bestimmten Nutzer auf einen neuen Google-Dienst zugreifen muss. Der Umfang des Zugriffs, der durch das Token abgedeckt wird, hängt vom Google-Dienst ab. Dieser kann den Zugriff auf bestimmte Arten von Daten oder Aktivitäten einschränken, z. B. auf Lesezugriff.

Das von der AuthSub-Schnittstelle für ActionScript zurückgegebene Token kann beliebig oft verwendet werden, bis es widerrufen wird. Es liegt an Ihrer Anwendung, den Lebenszyklus des Tokens zu verwalten und dabei ein Gleichgewicht zwischen Sicherheit und Komfort zu finden. Google empfiehlt, jedes Mal, wenn eine neue Sitzung gestartet wird, ein neues Token anzufordern.

Bei einigen Google-Diensten ist der Zugriff möglicherweise nur über Webanwendungen möglich, die registriert sind und sichere Tokens verwenden. AuthSub für ActionScript wird für solche Dienste nicht unterstützt. Wenn Sie sichere Tokens verwenden möchten, muss Ihre Organisation ein SSL-Zertifikat bei Google registrieren und alle Anfragen für diese Datenfeeds signieren.

Nach oben