Aviso: esses dados são fornecidos de acordo com a Política de dados do usuário do Google . Reveja e cumpra a política. Não fazer isso pode resultar na suspensão do projeto ou suspensão da conta.

Autenticar com um back-end usando tokens de ID

O cliente de login do One Tap recupera um token de ID do Google quando o usuário seleciona uma conta do Google. Um token de ID é uma declaração assinada da identidade de um usuário que também contém informações básicas de perfil de um usuário, possivelmente incluindo um endereço de e-mail verificado pelo Google.

Quando os tokens de ID estão disponíveis, você pode usá-los para autenticar com segurança no back-end do seu aplicativo ou para inscrever automaticamente o usuário em uma nova conta sem a necessidade de verificar o endereço de e-mail do usuário.

Para entrar ou inscrever um usuário com um token de ID, envie o token para o back-end do seu aplicativo. No back-end, verifique o token usando uma biblioteca cliente da API do Google ou uma biblioteca JWT de uso geral. Se o usuário não fez login em seu aplicativo com esta Conta do Google antes, crie uma nova conta.

Obtenha um token de ID do objeto de credenciais

Depois de recuperar as credenciais de um usuário, verifique se o objeto de credenciais inclui um token de ID. Em caso afirmativo, envie-o para seu back-end.

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                  String idToken = credential.getGoogleIdToken();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  }
              } catch (ApiException e) {
                  // ...
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
             REQ_ONE_TAP -> {
                try {
                    val credential = oneTapClient.getSignInCredentialFromIntent(data)
                    val idToken = credential.googleIdToken
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
            }
        }
    }
    // ...
}

Verifique a integridade do token de ID

Depois de receber o token de ID por HTTPS POST, você deve verificar a integridade do token. Para verificar se o token é válido, certifique-se de que os seguintes critérios sejam atendidos:

  • O token de ID está devidamente assinado pelo Google. Use as chaves públicas do Google (disponíveis no formato JWK ou PEM ) para verificar a assinatura do token. Essas chaves são giradas regularmente; examine o cabeçalho Cache-Control na resposta para determinar quando você deve recuperá-los novamente.
  • O valor de aud no token de ID é igual a um dos IDs de cliente do seu aplicativo. Essa verificação é necessária para evitar que tokens de ID emitidos para um aplicativo malicioso sejam usados ​​para acessar dados sobre o mesmo usuário no servidor de back-end do seu aplicativo.
  • O valor de iss no token de ID é igual a accounts.google.com ou https://accounts.google.com .
  • O tempo de expiração ( exp ) do token de ID não passou.
  • Se você deseja restringir o acesso apenas a membros do seu domínio do G Suite, verifique se o token de ID tem uma declaração de hd que corresponda ao seu nome de domínio do G Suite.

Em vez de escrever seu próprio código para realizar essas etapas de verificação, recomendamos o uso de uma biblioteca cliente da API do Google para sua plataforma ou uma biblioteca JWT de uso geral. Para desenvolvimento e depuração, você pode chamar nosso tokeninfo validação de tokeninfo .

Usando uma biblioteca cliente de APIs do Google

Usar uma das bibliotecas de cliente da API do Google (por exemplo, Java , Node.js , PHP , Python ) é a maneira recomendada de validar tokens de ID do Google em um ambiente de produção.

Java

Para validar um token de ID em Java, use o objeto GoogleIdTokenVerifier . Por exemplo:

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

O método GoogleIdTokenVerifier.verify() verifica a assinatura JWT, a declaração de aud , a declaração de iss e a declaração de exp .

Se você quiser restringir o acesso apenas a membros do seu domínio do G Suite, verifique também a declaração hd verificando o nome de domínio retornado pelo método Payload.getHostedDomain() .

Node.js

Para validar um token de ID em Node.js, use a biblioteca de autenticação do Google para Node.js. Instale a biblioteca:

npm install google-auth-library --save
Em seguida, chame a função verifyIdToken() . Por exemplo:

const {OAuth2Client} = require('google-auth-library');
const client = new OAuth2Client(CLIENT_ID);
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);

A função verifyIdToken verifica a assinatura JWT, a declaração aud , a declaração exp e a declaração iss .

Se você deseja restringir o acesso apenas a membros do seu domínio do G Suite, verifique também se a declaração hd corresponde ao seu nome de domínio do G Suite.

PHP

Para validar um token de ID em PHP, use a biblioteca cliente de API do Google para PHP . Instale a biblioteca (por exemplo, usando o Composer):

composer require google/apiclient
Em seguida, chame a função verifyIdToken() . Por exemplo:

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
}

A função verifyIdToken verifica a assinatura JWT, a declaração aud , a declaração exp e a declaração iss .

Se você deseja restringir o acesso apenas a membros do seu domínio do G Suite, verifique também se a declaração hd corresponde ao seu nome de domínio do G Suite.

Pitão

Para validar um token de ID em Python, use a função verify_oauth2_token . Por exemplo:

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

A função verify_oauth2_token verifica a assinatura JWT, a declaração de aud e a declaração de exp . Você também deve verificar a declaração de hd (se aplicável) examinando o objeto que verify_oauth2_token retorna. Se vários clientes acessarem o servidor de back-end, verifique também manualmente a declaração de aud .

Chamando o endpoint tokeninfo

Uma maneira fácil de validar uma assinatura de token de ID para depuração é usar o terminal tokeninfo . Chamar este endpoint envolve uma solicitação de rede adicional que faz a maior parte da validação para você enquanto você testa a validação adequada e a extração de carga útil em seu próprio código. Não é adequado para uso em código de produção, pois as solicitações podem ser limitadas ou sujeitas a erros intermitentes.

Para validar um token de ID usando o terminal tokeninfo , faça uma solicitação HTTPS POST ou GET para o terminal e passe seu token de ID no parâmetro id_token . Por exemplo, para validar o token "XYZ123", faça a seguinte solicitação GET:

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

Se o token estiver devidamente assinado e as declarações iss e exp tiverem os valores esperados, você receberá uma resposta HTTP 200, em que o corpo contém as declarações de token de ID formatado em JSON. Aqui está um exemplo de resposta:

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

Se você é um cliente do G Suite, também pode se interessar pela declaração hd , que indica o domínio hospedado do usuário. Isso pode ser usado para restringir o acesso a um recurso apenas a membros de determinados domínios. A ausência dessa declaração indica que o usuário não pertence a um domínio hospedado pelo G Suite.

Crie uma conta ou sessão

Depois de verificar o token, verifique se o usuário já está no banco de dados do usuário. Em caso afirmativo, estabeleça uma sessão autenticada para o usuário. Se o usuário ainda não estiver em seu banco de dados do usuário, crie um novo registro do usuário a partir das informações na carga útil do token de ID e estabeleça uma sessão para o usuário. Você pode solicitar ao usuário qualquer informação adicional de perfil necessária ao detectar um usuário recém-criado em seu aplicativo.

Protegendo as contas dos seus usuários com Cross Account Protection

Ao contar com o Google para fazer o login de um usuário, você se beneficia automaticamente de todos os recursos e infraestrutura de segurança que o Google construiu para proteger os dados do usuário. No entanto, no caso improvável de comprometimento da Conta do Google do usuário ou de algum outro evento de segurança significativo, seu aplicativo também pode ficar vulnerável a ataques. Para proteger melhor suas contas de quaisquer eventos importantes de segurança, use a Cross Account Protection para receber alertas de segurança do Google. Ao receber esses eventos, você obtém visibilidade de mudanças importantes na segurança da conta do Google do usuário e pode, então, tomar medidas em seu serviço para proteger suas contas.