AuthSub in ActionScript verwenden

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

Hinweis: Wenn Sie bereits mit AuthSub vertraut sind, dem Kontoauthentifizierungsdienst für webbasierte Anwendungen von AuthSub, werden Sie feststellen, dass AuthSub für ActionScript konzeptionell sehr ähnlich ist. Die zugrunde liegende Implementierung ist anders, aber die Unterschiede sind für Sie als Entwickler von Clientanwendungen nicht wichtig. In einigen Fällen, in denen die Unterscheidung irrelevant ist, wird AuthSub für ActionScript als „AuthSub“ bezeichnet.

Über die Oberfläche von AuthSub für ActionScript können sich Flash- oder Silverlight-Anwendungen im Auftrag eines Nutzers bei geschützten Google Data API-Feeds authentifizieren. Die Benutzeroberfläche ermöglicht der Anwendung ein Authentifizierungstoken zu erhalten, ohne die Anmeldedaten des Nutzerkontos verarbeiten zu müssen. So wird ein hohes Maß an Sicherheit gewährleistet.

AuthSub für ActionScript ist eine Variante von AuthSub für JavaScript. Ebenso wie AuthSub für JavaScript bietet es eine domainübergreifende Methode zur Authentifizierung von Clientanwendungen über eine Webseite, die nicht in einer Google-Domain gehostet wird. Der Authentifizierungsdienst befindet sich in einer anderen Domain (accounts.googleapis.com statt www.google.com) und unterscheidet sich vom standardmäßigen AuthSub. Außerdem stellt er eine crossdomain.xml-Datei bereit, die externen Websites den Zugriff auf diese Domain ermöglicht.

Weitere Informationen zur Verwendung aller APIs für den Authentication-Dienst finden Sie in der Google Accounts API-Gruppe.

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 die allgemeinen Ideen für das Google Data APIs-Protokoll und die AuthSub-Oberfläche verstehen. Außerdem wird vorausgesetzt, dass Sie wissen, wie man in ActionScript programmiert.

Unterstützte Umgebungen

AuthSub für ActionScript wird derzeit in Firefox 1.5 und höher und 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

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

  1. Für den Zugriff auf einen Google Data-Dienst im Namen eines Nutzers 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 erwerben. Um ein Token zu erhalten, führt die Webanwendung einen AuthSub-Vorgang für den ActionScript-Anmeldeaufruf an den Authentifizierungsdienst aus und gibt den Dienst an, auf den zugegriffen werden soll.
  2. Beim Empfang der Anfrage von der Webanwendung leitet der Authentifizierungsdienst den Nutzer auf eine Seite „Zugriffsanfrage“ weiter. Auf dieser Seite wird der Nutzer aufgefordert, sich in seinem Google-Konto anzumelden und den Zugriff auf seinen Google-Dienst zu gewähren oder zu verweigern.
  3. Der Nutzer entscheidet, ob er Zugriff auf die Webanwendung erhält oder verweigert. Wenn der Nutzer den Zugriff verweigert, wird er zu einer Google-Seite weitergeleitet und nicht zur Webanwendung.
  4. Wenn sich der Nutzer erfolgreich anmeldet und Zugriff gewährt, leitet der Authentifizierungsdienst den Nutzer zurück zur Webanwendungs-URL, die den ursprünglichen Aufruf durchgeführt hat. Die Weiterleitung sendet ein Authentifizierungstoken für den angegebenen Dienst über einen Abfrageparameter. Die Anwendung sollte das Token als Cookie im Browser des Nutzers unter der Domain der Webanwendung speichern. Das Token ist gültig, bis es widerrufen wird. Informationen zum Widerrufen von Tokens finden Sie im Abschnitt Informationen zu Tokens.
  5. Die Webanwendung kontaktiert den Google Data-Dienst und sendet das Authentifizierungstoken zusammen mit jeder Anfrage, die an den Dienst gesendet wird.
  6. Wenn der Google Data-Dienst das Token erkennt, stellt er die angeforderten Daten bereit.

AuthSub für ActionScript verwenden

AuthSub für ActionScript oder AuthSubAS bietet einen domainübergreifenden AuthSub-Endpunkt für Flash- oder Silverlight-Anwendungen, die Google Data APIs verwenden.

AuthSubAS spiegelt die 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 verwendet werden.

Mit den folgenden Schritten wird ein Authentifizierungstoken abgerufen und verwendet, um über eine Flash-Anwendung auf einen Google-Dienst zuzugreifen.

  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 initialisieren. Rufen Sie dazu für jede Domain die ActionScript-Methode Security.loadPolicyFile(policy) 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

    Beachten Sie, dass wir hier die Richtlinien für accounts.googleapis.com (AuthSubAS) und photos.googleapis.com/data (PicasaWeb, auf die später im Beispiel zugegriffen wird) laden.

  2. Fordern Sie ein Token zur einmaligen Verwendung an.

    Im ersten Schritt des AuthSub-Prozesses wird ein Einweg-Token vom AuthSub-Endpunkt angefordert. Ihre Anwendung sollte dazu einen Aufruf an den AuthSubRequest-Endpunkt aufrufen. Beispiel:

          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

    Diese Methode erfordert einen scope-Wert. Jeder Google-Dienst definiert den zulässigen Zugriffsbereich. Auf diesen Bereich muss in der Tokenanfrage verwiesen werden. Informationen zum Ermitteln des Bereichswerts finden 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, mit der der Dienst identifiziert wird, oder um einen eingeschränkten Zugriff anzugeben, z. B. die Beschränkung auf den schreibgeschützten Zugriff. Wenn der Dienst eine Auswahl an Bereichen bietet, fordern Sie das Token mit dem strengsten Umfang an. Verwenden Sie beispielsweise für den Zugriff auf die Datenfeeds von Google Kalender den Bereich 'http://www.google.com/calendar/feeds', nicht 'http://www.google.com/calendar'.

    Tipps:

    • Wir empfehlen Ihnen dringend, eine Anmeldeschaltfläche oder einen anderen Mechanismus zur Nutzereingabe bereitzustellen, damit der Nutzer den Anmeldevorgang manuell starten kann. Wenn Sie die Website stattdessen direkt nach dem Laden überprüfen und weiterleiten, ohne auf die Interaktion des Nutzers zu warten, sieht der Nutzer als Erstes eine Google-Anmeldeseite. Wenn sich der Nutzer entscheidet, sich nicht anzumelden, leitet Google ihn nicht zurück auf Ihre Seite. Er hat also versucht, Ihre Seite zu besuchen, 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 Endpunkt AuthSubRequest gibt ein Einweg-Token an Ihre Anwendung zurück. Dazu wird die URL des Browsers des Nutzers auf http://yourWebAppUrl?token=singleUseToken gesetzt. Sobald Ihre Anwendung ihr Token zur einmaligen Verwendung erhalten hat, muss sie das Token gegen ein Token mit langer Nutzungsdauer austauschen, das dann für Anfragen an Google Data-Feeds verwendet werden kann. Rufen Sie dazu die Methode AuthSubSessionToken mit dem einmaligen Token auf.

    Die Anwendung sollte beim Laden nach dem Parameter token in der URL 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 es eine Methode wie getLongLivedToken aufrufen, die den Endpunkt AuthSubSessionToken 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 Ihnen dringend, das Langzeittoken in einem Cookie zu speichern und es vor der kurzfristigen Tokenprüfung zu prüfen. So müssen Nutzer nicht jedes Mal die AuthSub-Bestätigungsseite aufrufen, wenn sie Ihre Anwendung verwenden möchten.

  4. Mit einem Authentifizierungstoken

    Hängen Sie das Authentifizierungstoken ü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 Fotodienst:

          // 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 manuelle Abmeldefunktion wie eine Schaltfläche zum Abmelden oder einen anklickbaren Link anzubieten. Bei diesem Ansatz können sich Nutzer jederzeit abmelden oder ihre Daten-Feeds für den nächsten Zugriff auf Ihre Anwendung speichern.

Tokens

In diesem Abschnitt werden die Token beschrieben, die von AuthSub für ActionScript verwendet werden. In den meisten Kontexten benötigen Sie diese Informationen nicht.

Jedes Authentifizierungstoken gilt speziell für die folgenden Daten:

  • Umfang des Google-Dienstes
  • 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 Umfang, 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 Zugriff auf einen neuen Google-Dienst benötigt. Der Zugriffsbereich des Tokens hängt vom Google-Dienst ab, der den Zugriff auf bestimmte Arten von Daten oder Aktivitäten beschränken kann, z. B. auf Lesezugriff.

Das von der AuthSub für ActionScript zurückgegebene Token kann so oft wie nötig verwendet werden, bis es widerrufen wird. Es liegt an Ihrer Anwendung, die Lebensdauer des Tokens zu verwalten und Sicherheit mit Komfort auszugleichen. Google empfiehlt, bei jeder neuen Sitzung ein neues Token anzufordern.

Einige Google-Dienste erlauben möglicherweise nur den Zugriff über registrierte Webanwendungen, die sichere Tokens verwenden. AuthSub für ActionScript wird für solche Dienste nicht unterstützt. Um sichere Tokens verwenden zu können, muss Ihre Organisation ein SSL-Zertifikat bei Google registrieren und alle Anfragen für diese Datenfeeds signieren.

Nach oben