Ta strona została przetłumaczona przez Cloud Translation API.

Uwierzytelnianie za pomocą serwera backendu

Jeśli używasz Logowania przez Google w aplikacji lub na stronie, która komunikuje się z backendem serwera, może być konieczne zidentyfikowanie obecnie zalogowanego użytkownika na serwerze. Aby to zrobić w bezpieczny sposób, po zalogowaniu się użytkownika wyślij jego token identyfikacyjny na serwer za pomocą protokołu HTTPS. Następnie sprawdź na serwerze integralność i wykorzystać informacje o użytkowniku zawarte w tokenie do określenia lub utwórz nowe konto.

Ostrzeżenie: nie akceptuj na serwerze zaplecza zwykłych identyfikatorów użytkowników, takich jak te, które możesz uzyskać za pomocą funkcji GoogleSignInAccount.getId() method. Zmodyfikowana aplikacja kliencka może wysyłać dowolne identyfikatory użytkownika do do podszywania się pod użytkowników, więc musisz zamiast tego używać możliwych do zweryfikowania tokenów tożsamości do bezpiecznie pobierać identyfikatory zalogowanych użytkowników po stronie serwera.

Wyślij token identyfikatora na swój serwer

Najpierw gdy użytkownik się zaloguje, pobierz jego token identyfikatora:

Gdy skonfigurować Logowanie przez Google, Wywołaj funkcję requestIdToken i przekaż mu identyfikator klienta internetowego serwera.

// Request only the user's ID token, which can be used to identify the
// user securely to your backend. This will contain the user's basic
// profile (name, profile picture URL, etc) so you should not need to
// make an additional call to personalize your application.
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken(getString(R.string.server_client_id))
        .requestEmail()
        .build();

Po uruchomieniu aplikacji sprawdź, czy użytkownik zalogował się w niej za pomocą Google na tym urządzeniu lub na innym, wywołując funkcję silentSignIn:

GoogleSignIn.silentSignIn()
    .addOnCompleteListener(
        this,
        new OnCompleteListener<GoogleSignInAccount>() {
          @Override
          public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
            handleSignInResult(task);
          }
        });

Jeśli użytkownik nie może się zalogować bez potwierdzenia, wyświetl normalny ekran logowania, oferując użytkownikowi możliwość zalogowania się. Gdy użytkownik zaloguje się, uzyskaj jego GoogleSignInAccount w aktywności będącej wynikiem zamiaru logowania:
```
// This task is always completed immediately, there is no need to attach an
// asynchronous listener.
Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data);
handleSignInResult(task);
```

Po zalogowaniu się użytkownika w sposób cichy lub jawny pobierz token identyfikacyjny z obiektu GoogleSignInAccount:

private void handleSignInResult(@NonNull Task<GoogleSignInAccount> completedTask) {
    try {
        GoogleSignInAccount account = completedTask.getResult(ApiException.class);
        String idToken = account.getIdToken();

        // TODO(developer): send ID Token to server and validate

        updateUI(account);
    } catch (ApiException e) {
        Log.w(TAG, "handleSignInResult:error", e);
        updateUI(null);
    }
}

Jeśli nie skonfigurujesz GoogleSignInOptions za pomocą requestIdToken, getIdToken zwróci wartość null.

Następnie wyślij token identyfikatora do serwera za pomocą żądania HTTPS POST:

HttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost("https://yourbackend.example.com/tokensignin");

try {
  List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(1);
  nameValuePairs.add(new BasicNameValuePair("idToken", idToken));
  httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

  HttpResponse response = httpClient.execute(httpPost);
  int statusCode = response.getStatusLine().getStatusCode();
  final String responseBody = EntityUtils.toString(response.getEntity());
  Log.i(TAG, "Signed in as: " + responseBody);
} catch (ClientProtocolException e) {
  Log.e(TAG, "Error sending ID token to backend.", e);
} catch (IOException e) {
  Log.e(TAG, "Error sending ID token to backend.", e);
}

Sprawdzanie integralności tokena tożsamości

Po otrzymaniu tokena identyfikatora za pomocą metody HTTPS POST musisz zweryfikować integralność tokenu.

如需验证令牌是否有效，请确保满足以下条件：

ID 令牌已由 Google 正确签名。使用 Google 的公钥（以 JWK 或 PEM 格式提供）验证令牌的签名。这些密钥会定期轮换；请检查响应中的 Cache-Control 标头，以确定何时应再次检索这些密钥。
ID 令牌中的 aud 值等于您应用的某个客户端 ID。此检查是必要的，可防止向恶意应用发放的 ID 令牌被用于访问您应用后端服务器上有关同一用户的数据。
ID 令牌中 iss 的值等于 accounts.google.com 或 https://accounts.google.com。
ID 令牌的到期时间 (exp) 尚未到期。
如果您需要验证 ID 令牌是否代表 Google Workspace 或 Cloud 组织账号，可以检查 hd 声明，该声明表示用户的托管网域。如果需要将对资源的访问权限限制为仅限特定网域的成员，则必须使用此方法。如果缺少此声明，则表示相应账号不属于 Google 托管网域。

通过使用 email、email_verified 和 hd 字段，您可以确定 Google 是否托管某个电子邮件地址并对其具有权威性。如果 Google 是权威方，则表示用户是合法的账号所有者，您可以跳过密码或其他身份验证方法。

Google 具有权威性的情况：

email 带有 @gmail.com 后缀，则表示这是 Gmail 账号。
email_verified 为 true 且设置了 hd，则为 Google Workspace 账号。

用户可以注册 Google 账号，而无需使用 Gmail 或 Google Workspace。如果 email 不包含 @gmail.com 后缀且 hd 不存在，则 Google 不具有权威性，建议使用密码或其他质询方法来验证用户身份。email_verified 也可能为 true，因为 Google 最初在创建 Google 账号时验证了用户身份，但第三方电子邮件账号的所有权可能已发生变化。

我们强烈建议您使用适用于您平台的 Google API 客户端库或通用 JWT 库，而不是自行编写代码来执行这些验证步骤。对于开发和调试，您可以调用我们的 tokeninfo 验证端点。

Korzystanie z biblioteki klienta interfejsów API Google

Używanie jednej z bibliotek klienta interfejsów API Google (np. Java Node.js, PHP, Pythona) to zalecany sposób weryfikacji tokenów tożsamości Google w środowisku produkcyjnym.

Jawa

Aby zweryfikować token identyfikatora w Javie, skorzystaj z GoogleIdTokenVerifier. Na przykład:

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 WEB_CLIENT_ID of the app that accesses the backend:
    .setAudience(Collections.singletonList(WEB_CLIENT_ID))
    // Or, if multiple clients access the backend:
    //.setAudience(Arrays.asList(WEB_CLIENT_ID_1, WEB_CLIENT_ID_2, WEB_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.");
}

Metoda GoogleIdTokenVerifier.verify() weryfikuje token JWT podpis, twierdzenie aud, roszczenie iss oraz Roszczenie exp.

Jeśli chcesz sprawdzić, czy token identyfikatora reprezentuje Google Workspace lub Cloud konta organizacji, możesz zweryfikować własność domeny hd, sprawdzając nazwę domeny zwracanymi przez metodę Payload.getHostedDomain(). Domena Roszczenie dotyczące email nie wystarcza do zapewnienia, że konto jest zarządzane przez domenę lub organizacji.

Node.js

Aby sprawdzić token identyfikatora w Node.js, użyj biblioteki uwierzytelniania Google dla Node.js. Zainstaluj bibliotekę:

npm install google-auth-library --save

Następnie wywołaj funkcję verifyIdToken(). Na przykład:

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

Funkcja verifyIdToken weryfikuje podpis JWT, deklaracja aud, deklaracja exp, i roszczenie iss.

Jeśli chcesz sprawdzić, czy token identyfikatora reprezentuje Google Workspace lub Cloud konta organizacji, możesz sprawdzić twierdzenie hd, które wskazuje, w domenie użytkownika. Tej opcji należy używać, gdy dostęp do zasobu mają tylko użytkownicy i konkretnych domen. Brak tego roszczenia oznacza, że konto nie należy do: jest domeną hostowaną przez Google.

PHP

Aby sprawdzić token identyfikatora w języku PHP, użyj biblioteki klienta interfejsów API Google dla języka PHP. Zainstaluj bibliotekę (np. za pomocą narzędzia Composer):

composer require google/apiclient

Następnie wywołaj funkcję verifyIdToken(). Na przykład:

require_once 'vendor/autoload.php';

// Get $id_token via HTTPS POST.

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

Funkcja verifyIdToken weryfikuje podpis JWT, deklaracja aud, deklaracja exp, i roszczenie iss.

Python

Aby sprawdzić token tożsamości w Pythonie, użyj instrukcji verify_oauth2_token . Na przykład:

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

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

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

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

    # If the request specified a Google Workspace domain
    # if idinfo['hd'] != DOMAIN_NAME:
    #     raise ValueError('Wrong domain name.')

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

Funkcja verify_oauth2_token weryfikuje token JWT podpis, roszczenie aud i roszczenie exp. Musisz też zweryfikować hd roszczenia (jeśli dotyczy) przez sprawdzenie obiektu, który verify_oauth2_token zwraca. Jeśli wielu klientów ma dostęp do serwera backendu, ręcznie zweryfikuj również deklarację aud.

Wywołanie punktu końcowego tokeninfo

Aby w prosty sposób sprawdzić podpis tokena identyfikatora na potrzeby debugowania, wykonaj te czynności: użyj punktu końcowego tokeninfo. Wywołanie tego punktu końcowego wymaga: dodatkowe żądanie sieciowe, które wykonuje większość weryfikacji za Ciebie podczas testowania prawidłowych; weryfikacji i wyodrębniania ładunku w ramach własnego kodu. Nie nadaje się do użytku w środowisku produkcyjnym ponieważ żądania mogą być ograniczane lub w inny sposób powodować sporadyczne błędy.

Aby zweryfikować token tożsamości za pomocą punktu końcowego tokeninfo, utwórz protokół HTTPS POST lub GET do punktu końcowego i przekaż swój token tożsamości w polu id_token. Aby na przykład zweryfikować token „XYZ123”, wyślij to żądanie GET:

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

Jeśli token jest prawidłowo podpisany, a iss i exp ma oczekiwane wartości, otrzymasz odpowiedź HTTP 200, gdzie treść zawiera deklaracje tokena identyfikatora w formacie JSON. Oto przykładowa odpowiedź:

{
 // 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"
}

Ostrzeżenie: gdy otrzymasz te roszczenia, musisz Sprawdź, czy roszczenie aud zawiera jeden z identyfikatorów klienta Twojej aplikacji. Jeśli tak, że token jest prawidłowy i przeznaczony dla klienta. Możesz bezpiecznie pobierać i używać unikalny identyfikator Google użytkownika z roszczenia sub.

Jeśli chcesz potwierdzić, że token identyfikatora reprezentuje konto Google Workspace, możesz to sprawdzić twierdzenie hd, które wskazuje hostowaną domenę użytkownika; Tej opcji należy użyć, gdy ograniczanie dostępu do zasobu wyłącznie członkom określonych domen. Brak tego roszczenia wskazuje, że konto nie należy do domeny hostowanej w Google Workspace.

Tworzenie konta lub sesji

Po zweryfikowaniu tokena sprawdź, czy użytkownik jest już na Twoim koncie w bazie danych. Jeśli tak, utwórz uwierzytelnioną sesję dla użytkownika. Jeśli użytkownik nie ma jeszcze w bazie danych użytkowników, utwórz nowy rekord użytkownika na podstawie tych informacji w ładunku tokena identyfikatora i ustanowić sesję dla użytkownika. Możesz prosić użytkownika do wszelkich dodatkowych informacji w profilu wymaganych po wykryciu nowego użytkownika w aplikacji.

Zabezpieczanie kont użytkowników za pomocą ochrony na wielu kontach

Gdy logowanie użytkownika jest obsługiwane przez Google, automatycznie korzystasz ze wszystkich funkcji bezpieczeństwa i infrastruktury opracowanych przez Google w celu ochrony danych użytkownika. Jednak w nieprawdopodobnym przypadku, gdy konto Google użytkownika zostanie skompromitowane lub wystąpi inny istotny incydent związany z bezpieczeństwem, Twoja aplikacja może być narażona na atak. Aby lepiej chronić swoje konta przed poważnymi zdarzeniami związanymi z bezpieczeństwem, użyj zabezpieczeń na wielu kontach, aby otrzymywać alerty dotyczące zabezpieczeń od Google. Gdy otrzymasz te zdarzenia, będziesz mieć dostęp do ważnych zmian dotyczących bezpieczeństwa konta Google użytkownika. Dzięki temu możesz podjąć działania w swojej usłudze, aby zabezpieczyć swoje konta.

Uwierzytelnianie za pomocą serwera backendu Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Wyślij token identyfikatora na swój serwer

Sprawdzanie integralności tokena tożsamości

Korzystanie z biblioteki klienta interfejsów API Google

Wywołanie punktu końcowego tokeninfo

Tworzenie konta lub sesji

Zabezpieczanie kont użytkowników za pomocą ochrony na wielu kontach

Uwierzytelnianie za pomocą serwera backendu