Diese Seite wurde von der Cloud Translation API übersetzt.

Mit einem Back-End-Server authentifizieren

Wenn du Google Log-in mit einer App oder Website verwendest, die mit einem Back-End-Server kommuniziert, musst du möglicherweise den aktuell angemeldeten Nutzer auf dem Server identifizieren. Nachdem sich ein Nutzer erfolgreich angemeldet hat, sende zu diesem Zweck das ID-Token des Nutzers über HTTPS an deinen Server. Prüfen Sie dann auf dem Server die Integrität des ID-Tokens und verwenden Sie die im Token enthaltenen Nutzerinformationen, um eine Sitzung einzurichten oder ein neues Konto zu erstellen.

Warnung:Akzeptieren Sie auf Ihrem Back-End-Server keine einfachen Nutzer-IDs, wie sie beispielsweise mit GIDGoogleUser.userID property abgerufen werden können. Eine geänderte Clientanwendung kann beliebige Nutzer-IDs an Ihren Server senden, um die Identität von Nutzern zu übernehmen. Daher müssen Sie stattdessen überprüfbare ID-Tokens verwenden, um die Nutzer-IDs angemeldeter Nutzer serverseitig sicher abzurufen.

ID-Token an Server senden

Nachdem sich ein Nutzer erfolgreich angemeldet hat, rufen Sie das ID-Token des Nutzers ab:

Swift

GIDSignIn.sharedInstance.signIn(withPresenting: self) { signInResult, error in
    guard error == nil else { return }
    guard let signInResult = signInResult else { return }

    signInResult.user.refreshTokensIfNeeded { user, error in
        guard error == nil else { return }
        guard let user = user else { return }

        let idToken = user.idToken
        // Send ID token to backend (example below).
    }
}

Objective-C

[GIDSignIn.sharedInstance signInWithPresentingViewController:self
                                              completion:^(GIDSignInResult * _Nullable signInResult,
                                                           NSError * _Nullable error) {
      if (error) { return; }
      if (signInResult == nil) { return; }

      [signInResult.user refreshTokensIfNeededWithCompletion:^(GIDGoogleUser * _Nullable user,
                                                               NSError * _Nullable error) {
          if (error) { return; }
          if (user == nil) { return; }

          NSString *idToken = user.idToken;
          // Send ID token to backend (example below).
      }];
}];

Senden Sie dann das ID-Token mit einer HTTPS-POST-Anfrage an Ihren Server:

Swift

func tokenSignInExample(idToken: String) {
    guard let authData = try? JSONEncoder().encode(["idToken": idToken]) else {
        return
    }
    let url = URL(string: "https://yourbackend.example.com/tokensignin")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")

    let task = URLSession.shared.uploadTask(with: request, from: authData) { data, response, error in
        // Handle response from your backend.
    }
    task.resume()
}

Objective-C

NSString *signinEndpoint = @"https://yourbackend.example.com/tokensignin";
NSDictionary *params = @{@"idtoken": idToken};

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:signinEndpoint];
[request setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"];
[request setHTTPMethod:@"POST"];
[request setHTTPBody:[self httpBodyForParamsDictionary:params]];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[NSURLConnection sendAsynchronousRequest:request
                                   queue:queue
                       completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) {
                         if (error) {
                           NSLog(@"Error: %@", error.localizedDescription);
                         } else {
                           NSLog(@"Signed in as %@", data.bytes);
                         }
                       }];

Integrität des ID-Tokens prüfen

Nachdem Sie das ID-Token über HTTPS POST erhalten haben, müssen Sie die Integrität des Tokens prüfen.

Prüfen Sie, ob die folgenden Kriterien erfüllt sind:

Das ID-Token ist ordnungsgemäß von Google signiert. Verwenden Sie die öffentlichen Schlüssel von Google (verfügbar im Format JWK oder PEM), um die Signatur des Tokens zu prüfen. Diese Schlüssel werden regelmäßig rotiert. Prüfen Sie den Cache-Control-Header in der Antwort, um festzustellen, wann Sie sie noch einmal abrufen sollten.
Der Wert von aud im ID-Token entspricht einer der Client-IDs der Anwendung. Diese Prüfung ist erforderlich, um zu verhindern, dass ID-Tokens, die an eine schädliche Anwendung gesendet wurden, für den Zugriff auf Daten desselben Nutzers auf dem Back-End-Server der Anwendung verwendet werden.
Der Wert von iss im ID-Token ist accounts.google.com oder https://accounts.google.com.
Die Ablaufzeit (exp) des ID-Tokens ist noch nicht verstrichen.
Wenn Sie überprüfen müssen, ob das ID-Token ein Google Workspace- oder Cloud-Organisationskonto darstellt, können Sie die hd-Anforderung prüfen, die die gehostete Domain des Nutzers angibt. Dies muss verwendet werden, wenn der Zugriff auf eine Ressource auf Mitglieder bestimmter Domains beschränkt werden soll. Falls dieser Anspruch fehlt, bedeutet das, dass das Konto nicht zu einer von Google gehosteten Domain gehört.

Anstatt eigenen Code zu schreiben, um diese Überprüfungsschritte auszuführen, empfehlen wir dringend, eine Google API-Clientbibliothek für Ihre Plattform oder eine allgemeine JWT-Bibliothek zu verwenden. Zur Entwicklung und Fehlerbehebung können Sie unseren Validierungsendpunkt tokeninfo aufrufen.

Google API-Clientbibliothek verwenden

Die Verwendung einer der Google API-Clientbibliotheken (z.B. Java, Node.js, PHP, Python) wird zum Prüfen von Google-ID-Tokens in einer Produktionsumgebung empfohlen.

Java

Verwenden Sie das Objekt GoogleIdTokenVerifier, um ein ID-Token in Java zu validieren. Beispiel:

import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;

...

GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, jsonFactory)
    // Specify the CLIENT_ID of the app that accesses the backend:
    .setAudience(Collections.singletonList(CLIENT_ID))
    // Or, if multiple clients access the backend:
    //.setAudience(Arrays.asList(CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3))
    .build();

// (Receive idTokenString by HTTPS POST)

GoogleIdToken idToken = verifier.verify(idTokenString);
if (idToken != null) {
  Payload payload = idToken.getPayload();

  // Print user identifier
  String userId = payload.getSubject();
  System.out.println("User ID: " + userId);

  // Get profile information from payload
  String email = payload.getEmail();
  boolean emailVerified = Boolean.valueOf(payload.getEmailVerified());
  String name = (String) payload.get("name");
  String pictureUrl = (String) payload.get("picture");
  String locale = (String) payload.get("locale");
  String familyName = (String) payload.get("family_name");
  String givenName = (String) payload.get("given_name");

  // Use or store profile information
  // ...

} else {
  System.out.println("Invalid ID token.");
}

Die Methode GoogleIdTokenVerifier.verify() überprüft die JWT-Signatur, die aud-Anforderung, die iss-Anforderung und die exp-Anforderung.

Wenn Sie überprüfen müssen, ob das ID-Token ein Google Workspace- oder Cloud-Organisationskonto darstellt, können Sie die hd-Anforderung prüfen. Dazu prüfen Sie den Domainnamen, der von der Methode Payload.getHostedDomain() zurückgegeben wird. Die Domain der email-Anforderung reicht nicht aus, um dafür zu sorgen, dass das Konto von einer Domain oder Organisation verwaltet wird.

Node.js

Verwenden Sie zum Prüfen eines ID-Tokens in Node.js die Google-Authentifizierungsbibliothek für Node.js. Installieren Sie die Bibliothek:

npm install google-auth-library --save

Rufen Sie dann die Funktion verifyIdToken() auf. Beispiel:

const {OAuth2Client} = require('google-auth-library');
const client = new OAuth2Client();
async function verify() {
  const ticket = await client.verifyIdToken({
      idToken: token,
      audience: CLIENT_ID,  // Specify the CLIENT_ID of the app that accesses the backend
      // Or, if multiple clients access the backend:
      //[CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3]
  });
  const payload = ticket.getPayload();
  const userid = payload['sub'];
  // If request specified a G Suite domain:
  // const domain = payload['hd'];
}
verify().catch(console.error);

Die Funktion verifyIdToken prüft die JWT-Signatur, die aud-Anforderung, die exp- und die iss-Anforderung.

Wenn Sie überprüfen müssen, ob das ID-Token ein Google Workspace- oder Cloud-Organisationskonto darstellt, können Sie die hd-Anforderung prüfen, die die gehostete Domain des Nutzers angibt. Dies muss verwendet werden, wenn der Zugriff auf eine Ressource auf Mitglieder bestimmter Domains beschränkt werden soll. Falls dieser Anspruch fehlt, bedeutet das, dass das Konto nicht zu einer von Google gehosteten Domain gehört.

PHP

Mit der Google API-Clientbibliothek für PHP können Sie ein ID-Token in PHP validieren. Installieren Sie die Bibliothek, z. B. mit Composer:

composer require google/apiclient

Rufen Sie dann die Funktion verifyIdToken() auf. Beispiel:

require_once 'vendor/autoload.php';

// Get $id_token via HTTPS POST.

$client = new Google_Client(['client_id' => $CLIENT_ID]);  // Specify the CLIENT_ID of the app that accesses the backend
$payload = $client->verifyIdToken($id_token);
if ($payload) {
  $userid = $payload['sub'];
  // If request specified a G Suite domain:
  //$domain = $payload['hd'];
} else {
  // Invalid ID token
}

Die Funktion verifyIdToken prüft die JWT-Signatur, die aud-Anforderung, die exp- und die iss-Anforderung.

Python

Verwenden Sie die Funktion verify_oauth2_token, um ein ID-Token in Python zu validieren. Beispiel:

from google.oauth2 import id_token
from google.auth.transport import requests

# (Receive token by HTTPS POST)
# ...

try:
    # Specify the CLIENT_ID of the app that accesses the backend:
    idinfo = id_token.verify_oauth2_token(token, requests.Request(), CLIENT_ID)

    # Or, if multiple clients access the backend server:
    # idinfo = id_token.verify_oauth2_token(token, requests.Request())
    # if idinfo['aud'] not in [CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3]:
    #     raise ValueError('Could not verify audience.')

    # If auth request is from a G Suite domain:
    # if idinfo['hd'] != GSUITE_DOMAIN_NAME:
    #     raise ValueError('Wrong hosted domain.')

    # ID token is valid. Get the user's Google Account ID from the decoded token.
    userid = idinfo['sub']
except ValueError:
    # Invalid token
    pass

Die Funktion verify_oauth2_token überprüft die JWT-Signatur, die aud-Anforderung und die exp-Anforderung. Sie müssen auch die hd-Anforderung (falls zutreffend) verifizieren, indem Sie das Objekt untersuchen, das verify_oauth2_token zurückgibt. Wenn mehrere Clients auf den Back-End-Server zugreifen, prüfen Sie die aud-Anforderung auch manuell.

Tokeninfo-Endpunkt aufrufen

Eine einfache Möglichkeit zur Validierung einer ID-Token-Signatur für das Debugging ist die Verwendung des Endpunkts tokeninfo. Das Aufrufen dieses Endpunkts erfordert eine zusätzliche Netzwerkanfrage, die den Großteil der Validierung für Sie übernimmt, während Sie die ordnungsgemäße Validierung und die Extraktion der Nutzlast in Ihrem eigenen Code testen. Sie ist nicht für die Verwendung in Produktionscode geeignet, da Anfragen gedrosselt oder auf andere Weise zeitweilig auftretenden Fehlern ausgesetzt werden können.

Wenn Sie ein ID-Token mit dem Endpunkt tokeninfo validieren möchten, senden Sie eine HTTPS-POST- oder -GET-Anfrage an den Endpunkt und übergeben Sie Ihr ID-Token im Parameter id_token. Um beispielsweise das Token "XYZ123" zu validieren, führen Sie die folgende GET-Anfrage aus:

https://oauth2.googleapis.com/tokeninfo?id_token=XYZ123

Wenn das Token ordnungsgemäß signiert ist und die Anforderungen iss und exp die erwarteten Werte haben, erhalten Sie eine HTTP 200-Antwort, in der der Text die ID-Token-Anforderungen im JSON-Format enthält. Sie sehen hier ein Beispiel:

{
 // These six fields are included in all Google ID Tokens.
 "iss": "https://accounts.google.com",
 "sub": "110169484474386276334",
 "azp": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "aud": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "iat": "1433978353",
 "exp": "1433981953",

 // These seven fields are only included when the user has granted the "profile" and
 // "email" OAuth scopes to the application.
 "email": "testuser@gmail.com",
 "email_verified": "true",
 "name" : "Test User",
 "picture": "https://lh4.googleusercontent.com/-kYgzyAWpZzJ/ABCDEFGHI/AAAJKLMNOP/tIXL9Ir44LE/s99-c/photo.jpg",
 "given_name": "Test",
 "family_name": "User",
 "locale": "en"
}

Warnung:Auch bei Erhalt dieser Anforderungen müssen Sie prüfen, ob die aud-Anforderung eine der Client-IDs Ihrer Anwendung enthält. Ist dies der Fall, ist das Token gültig und für Ihren Client bestimmt. Sie können die eindeutige Google-ID des Nutzers sicher aus der sub-Anforderung abrufen und verwenden.

Wenn du überprüfen musst, ob das ID-Token ein Google Workspace-Konto darstellt, kannst du die hd-Anforderung prüfen, die die gehostete Domain des Nutzers angibt. Dies muss verwendet werden, wenn der Zugriff auf eine Ressource auf Mitglieder bestimmter Domains beschränkt werden soll. Falls dieser Anspruch fehlt, bedeutet das, dass das Konto nicht zu einer von Google Workspace gehosteten Domain gehört.

Konto oder Sitzung erstellen

Nachdem Sie das Token verifiziert haben, prüfen Sie, ob sich der Nutzer bereits in Ihrer Nutzerdatenbank befindet. Richten Sie in diesem Fall eine authentifizierte Sitzung für den Nutzer ein. Wenn sich der Nutzer noch nicht in Ihrer Nutzerdatenbank befindet, erstellen Sie aus den Informationen in der Nutzlast des ID-Tokens einen neuen Nutzerdatensatz und richten Sie eine Sitzung für den Nutzer ein. Sie können den Nutzer zur Eingabe zusätzlicher Profilinformationen auffordern, wenn Sie einen neu erstellten Nutzer in Ihrer Anwendung erkennen.

Nutzerkonten mit dem produktübergreifenden Kontoschutz schützen

Wenn Sie sich auf die Anmeldung eines Nutzers durch Google verlassen, profitieren Sie automatisch von allen Sicherheitsfunktionen und der Infrastruktur, die Google zum Schutz der Nutzerdaten entwickelt hat. Im unwahrscheinlichen Fall, dass das Google-Konto des Nutzers manipuliert wird oder ein anderes schwerwiegendes Sicherheitsereignis auftritt, kann Ihre Anwendung jedoch auch anfällig für Angriffe sein. Mit dem produktübergreifenden Kontoschutz können Sie Ihre Konten besser vor größeren Sicherheitsereignissen schützen und Sicherheitswarnungen von Google erhalten. Wenn Sie diese Ereignisse erhalten, erhalten Sie Einblick in wichtige Änderungen in Bezug auf die Sicherheit der Google-Konten des Nutzers und können dann Maßnahmen in Bezug auf Ihren Dienst ergreifen, um Ihre Konten zu schützen.