Verificar o token de ID do Google no lado do servidor

Depois que o Google retorna um token de ID, ele é enviado por uma solicitação de método HTTP POST, com o nome do parâmetro credential, para o endpoint de login.

Confira abaixo um exemplo na linguagem Python que mostra as etapas usuais para validar e consumir o token de ID:

1. Verifique o token de falsificação de solicitações entre sites (CSRF). Quando você envia as credenciais para o endpoint de login, usamos o padrão de envio duplo de cookies para evitar ataques CSRF. Antes de cada envio, geramos um token. Em seguida, o token é colocado no cookie e no corpo da postagem, conforme mostrado no exemplo de código abaixo:

   csrf_token_cookie = self.request.cookies.get('g_csrf_token')
   if not csrf_token_cookie:
       webapp2.abort(400, 'No CSRF token in Cookie.')
   csrf_token_body = self.request.get('g_csrf_token')
   if not csrf_token_body:
       webapp2.abort(400, 'No CSRF token in post body.')
   if csrf_token_cookie != csrf_token_body:
       webapp2.abort(400, 'Failed to verify double submit cookie.')
   

2. Verifique o token de ID.

   Para verificar se o token é válido, verifique se: critérios sejam atendidos:

   • O token de ID está devidamente assinado pelo Google. Usar as chaves públicas do Google (disponível em JWK ou PEM) para verificar a assinatura do token. Essas chaves são trocadas regularmente. examinar o cabeçalho Cache-Control na resposta para determinar quando você deve recuperá-las novamente.
   • O valor de aud no token de ID é igual a um dos IDs de clientes. Essa verificação é necessária para evitar que os tokens de ID emitidos para um dispositivo app sendo usado para acessar dados sobre o mesmo usuário no servidor de back-end do seu app.
   • O valor de iss no token de ID é igual a accounts.google.com ou https://accounts.google.com.
   • O prazo de validade (exp) do token de ID não passou.
   • Se você precisar validar se o token de ID representa uma conta do Google Workspace ou da organização, verifique a declaração hd, que indica o servidor domínio do usuário. Isso deve ser usado ao restringir o acesso a um recurso apenas a membros da determinados domínios. A ausência dessa reivindicação indica que a conta não pertence a Domínio hospedado pelo Google.

   Usando os campos email, email_verified e hd, é possível determinar se O Google hospeda e é autoritativo para um endereço de e-mail. Nos casos em que o Google é confiável, o usuário é conhecido como o proprietário legítimo da conta, e você pode ignorar a senha ou outras e métodos de desafio.

   Casos em que o Google é confiável:

   • email tem o sufixo @gmail.com. Esta é uma conta do Gmail.
   • A opção email_verified é verdadeira e hd foi definida. Esta é uma conta do G Suite.

   Os usuários podem se registrar para Contas do Google sem usar o Gmail ou o G Suite. Quando email não contém um sufixo @gmail.com e hd está ausente, o Google não está com autoridade e senha ou outros métodos de desafio o usuário. email_verified também pode ser verdadeiro porque o Google verificou inicialmente o usuário quando a Conta do Google foi criada, mas a propriedade do terceiro pode ter mudado desde então.

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

   Using a Google API Client Library

   Using one of the Google API Client Libraries (e.g. Java, Node.js, PHP, Python) is the recommended way to validate Google ID tokens in a production environment.

   Java

   To validate an ID token in Java, use the GoogleIdTokenVerifier object. For example:

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

   The GoogleIdTokenVerifier.verify() method verifies the JWT signature, the aud claim, the iss claim, and the exp claim.

   If you need to validate that the ID token represents a Google Workspace or Cloud organization account, you can verify the hd claim by checking the domain name returned by the Payload.getHostedDomain() method. The domain of the email claim is insufficient to ensure that the account is managed by a domain or organization.

   Node.js

   To validate an ID token in Node.js, use the Google Auth Library for Node.js. Install the library:

   npm install google-auth-library --save

   Then, call the verifyIdToken() function. For example:

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

   The verifyIdToken function verifies the JWT signature, the aud claim, the exp claim, and the iss claim.

   If you need to validate that the ID token represents a Google Workspace or Cloud organization account, you can check the hd claim, which indicates the hosted domain of the user. This must be used when restricting access to a resource to only members of certain domains. The absence of this claim indicates that the account does not belong to a Google hosted domain.

   PHP

   To validate an ID token in PHP, use the Google API Client Library for PHP. Install the library (for example, using Composer):

   composer require google/apiclient

   Then, call the verifyIdToken() function. For example:

   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
   }

   The verifyIdToken function verifies the JWT signature, the aud claim, the exp claim, and the iss claim.

   If you need to validate that the ID token represents a Google Workspace or Cloud organization account, you can check the hd claim, which indicates the hosted domain of the user. This must be used when restricting access to a resource to only members of certain domains. The absence of this claim indicates that the account does not belong to a Google hosted domain.

   Python

   To validate an ID token in Python, use the verify_oauth2_token function. For example:

   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

   The verify_oauth2_token function verifies the JWT signature, the aud claim, and the exp claim. You must also verify the hd claim (if applicable) by examining the object that verify_oauth2_token returns. If multiple clients access the backend server, also manually verify the aud claim.

   Ponto-chave :o token de ID é retornado no campo credential, em vez de no campo g_csrf_token.

3. Depois que a validade do token for confirmada, você poderá usar as informações no token de ID do Google para correlacionar o status da conta do seu site:

   • Um usuário não registrado:é possível mostrar uma interface do usuário (IU) de inscrição que permita que o usuário forneça outras informações de perfil, se necessário. Ele também permite que o usuário crie a nova conta e uma sessão de usuário conectado.

   • Uma conta que já existe no seu site:é possível mostrar uma página da Web que permite que o usuário final insira a senha e vincule a conta legada às credenciais do Google. Isso confirma que o usuário tem acesso à conta.

   • Um usuário federado que retorna:é possível fazer o login do usuário em segundo plano.

Importante: use apenas o campo Token de ID do Google sub como identificador do usuário, porque ele é exclusivo entre todas as Contas do Google e nunca é reutilizado. Armazene o campo sub e o associe ao usuário no seu sistema de gerenciamento de contas. Embora seja possível usar o endereço de e-mail do token de ID para verificar se o usuário tem uma conta, não use o endereço de e-mail como identificador, porque uma Conta do Google pode ter vários endereços de e-mail em momentos diferentes.