Verificar o token de ID do Google no lado do servidor

Ao usar os Serviços de identidade do Google ou o fluxo de código de autorização do OAuth 2.0, o Google retorna o token de ID usando o método POST para o endpoint de redirecionamento. Como alternativa, o fluxo implícito do OIDC usa uma solicitação GET. Consequentemente, seu aplicativo é responsável por transmitir com segurança essas credenciais recebidas ao servidor.

GET

Esse é o fluxo implícito. O token de ID é retornado no fragmento de URL, que precisa ser analisado pelo JavaScript do lado do cliente. O aplicativo é responsável por implementar os próprios mecanismos de validação para garantir a autenticidade da solicitação e evitar ataques como CSRF.

    HTTP/1.1 302 Found
    Location: https://<REDIRECT_URI>#access_token=<ACCESS_TOKEN>&token_type=bearer&expires_in=<TIME_IN_SECONDS>&scope=<SCOPE>&state=<STATE_STRING>
    

POST

O token de ID é enviado de volta como o campo credential. Ao preparar o envio do token de ID para o servidor, a biblioteca GIS adiciona automaticamente o g_csrf_token ao cookie de cabeçalho e ao corpo da solicitação. Este é um exemplo de solicitação POST:

POST /auth/token-verification HTTP/1.1
Host: example.com
Content-Type: application/json;charset=UTF-8
Cookie: g_csrf_token=<CSRF_TOKEN>
Origin: https://example.com
Content-Length: <LENGTH_OF_JSON_BODY>
    {
      "credential": "<ID_TOKEN>",
      "g_csrf_token": "<CSRF_TOKEN>",
      "client_id": "<CLIENT_ID>"
    }

1. Validar o g_csrf_token para evitar ataques de falsificação de solicitações entre sites (CSRF):

   • Extraia o valor do token CSRF do cookie g_csrf_token.
   • Extraia o valor do token CSRF do corpo da solicitação. A biblioteca GIS inclui esse token no corpo da solicitação POST como um parâmetro, também chamado g_csrf_token.
   • Compare os dois valores de token.
     • Se os dois valores estiverem presentes e forem totalmente iguais, a solicitação será considerada legítima e originada do seu domínio.
     • Se os valores não estiverem presentes ou não corresponderem, a solicitação precisará ser rejeitada pelo servidor. Essa verificação garante que a solicitação foi iniciada em JavaScript executado no seu próprio domínio, já que apenas ele pode acessar o cookie g_csrf_token.

2. Verifique o token de ID.

   Para verificar se o token é válido, confira se os seguintes critérios são atendidos:

   • O token de ID é assinado corretamente pelo Google. Use as chaves públicas do Google (disponíveis nos formatos JWK ou PEM) para verificar a assinatura do token. Essas chaves são trocadas regularmente. Examine 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 cliente do seu app. Essa verificação é necessária para evitar que tokens de ID emitidos para um app malicioso sejam usados 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 ainda não expirou.
   • Se você precisar validar se o token de ID representa uma conta de organização do Google Workspace ou do Cloud, verifique a declaração hd, que indica o domínio hospedado do usuário. Isso precisa ser usado ao restringir o acesso a um recurso apenas a membros de determinados domínios. A ausência dessa declaração indica que a conta não pertence a um domínio hospedado pelo Google.

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

   Casos em que o Google é autoridade:

   • Se o nome de usuário de email tiver o sufixo @gmail.com, ele será uma conta do Gmail.
   • email_verified é verdadeiro e hd está definido, essa é uma conta do Google Workspace.

   Os usuários podem se registrar para ter Contas do Google sem usar o Gmail ou o Google Workspace. Quando email não contém um sufixo @gmail.com e hd está ausente, o Google não é autoritário, e é recomendável usar senha ou outros métodos de desafio para verificar o usuário. email_verified também pode ser verdadeiro, já que o Google verificou inicialmente o usuário quando a Conta do Google foi criada. No entanto, a propriedade da conta de e-mail de terceiros pode ter mudado desde então.

   Em vez de escrever seu próprio código para realizar essas etapas de verificação, recomendamos usar uma biblioteca de cliente das APIs do Google para sua plataforma ou uma biblioteca JWT de uso geral. Para desenvolvimento e depuração, chame nosso endpoint de validação tokeninfo.

   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. This ID is unique to each Google Account, making it suitable for
     // use as a primary key during account lookup. Email is not a good choice because it can be
     // changed by the user.
     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();
     // This ID is unique to each Google Account, making it suitable for use as a primary key
     // during account lookup. Email is not a good choice because it can be changed by the user.
     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) {
     // This ID is unique to each Google Account, making it suitable for use as a primary key
     // during account lookup. Email is not a good choice because it can be changed by the user.
     $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.
       # This ID is unique to each Google Account, making it suitable for use as a primary key
       # during account lookup. Email is not a good choice because it can be changed by the user.
       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 do campo g_csrf_token.

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

   • Um usuário não registrado:você pode mostrar uma interface do usuário (UI) de inscrição que permite ao usuário fornecer mais informações de perfil, se necessário. Ele também permite que o usuário crie silenciosamente a nova conta e uma sessão de usuário conectado.

   • Uma conta que já existe no seu site:você pode 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 atual.

   • Um usuário federado recorrente:você pode fazer login silenciosamente.

Importante: use apenas o campo token de ID do Google sub como identificador do usuário, já que ele é exclusivo entre todas as Contas do Google e nunca é reutilizado. Armazene o campo sub e associe-o 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 um identificador, porque uma Conta do Google pode ter vários endereços de e-mail em diferentes momentos.