Autenticar com um servidor de back-end

Se você usa o Login do Google com um app ou site que se comunica com um servidor de back-end, talvez seja necessário identificar o usuário conectado no servidor. Para fazer isso com segurança, depois que um usuário fizer login, envie o token do ID do usuário para o servidor usando HTTPS. Em seguida, no servidor, verifique a integridade do token de ID e use as informações do usuário contidas nele para estabelecer uma sessão ou criar uma nova conta.

Enviar o token do ID para seu servidor

Depois que um usuário fizer login, consiga o token de ID dele:

function onSignIn(googleUser) {
  var id_token = googleUser.getAuthResponse().id_token;
  ...
}

Em seguida, envie o token de ID para o seu servidor com uma solicitação HTTPS POST:

var xhr = new XMLHttpRequest();
xhr.open('POST', 'https://yourbackend.example.com/tokensignin');
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.onload = function() {
  console.log('Signed in as: ' + xhr.responseText);
};
xhr.send('idtoken=' + id_token);

Verificar a integridade do token de ID

Depois de receber o token de ID por HTTPS POST, verifique a integridade do token.

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.

使用 Google API 客户端库

在生产环境中验证 Google ID 令牌时，建议使用一个 Google API 客户端库（例如 Java、Node.js、PHP、Python）。

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

npm install google-auth-library --save

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 the request specified a Google Workspace domain:
  // const domain = payload['hd'];
}
verify().catch(console.error);

composer require google/apiclient

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 the request specified a Google Workspace domain
  //$domain = $payload['hd'];
} else {
  // Invalid ID token
}

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

调用 tokeninfo 端点

若要验证用于调试的 ID 令牌签名，一种简单的方法是使用 tokeninfo 端点。调用此端点涉及到一个额外的网络请求，该网络请求会为您执行大部分验证，而您在自己的代码中测试适当的验证和载荷提取时。它不适合在生产代码中使用，因为请求可能会受到限制或出现间歇性错误。

如需使用 tokeninfo 端点验证 ID 令牌，请向该端点发出 HTTPS POST 或 GET 请求，并在 id_token 参数中传递您的 ID 令牌。例如，要验证令牌“XYZ123”，可发出以下 GET 请求：

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

如果令牌已正确签名，并且 iss 和 exp 声明具有预期值，您会收到 HTTP 200 响应，其正文包含 JSON 格式的 ID 令牌声明。以下是示例响应：

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

如果您需要验证此 ID 令牌是否代表 Google Workspace 帐号，可以检查 hd 声明，该声明指示用户的托管网域。仅允许特定网域的成员访问资源时，必须使用此方法。缺少此声明表示帐号不属于 Google Workspace 托管网域。

Criar uma conta ou sessão

Depois de verificar o token, verifique se o usuário já está no banco de dados de usuários. Se for o caso, estabeleça uma sessão autenticada para o usuário. Se o usuário ainda não estiver no banco de dados, crie um novo registro usando as informações no payload do token de ID e estabeleça uma sessão para o usuário. Você pode solicitar outras informações de perfil necessárias ao detectar um usuário recém-criado no app.

Como proteger as contas dos usuários com a Proteção entre contas

Ao confiar no Google para fazer o login de um usuário, você aproveita automaticamente todos os recursos de segurança e a infraestrutura que o Google criou para proteger os dados do usuário. No entanto, no caso improvável de a Conta do Google do usuário ser comprometida ou de alguma outra ocorrência de segurança significativa, seu app também poderá ficar vulnerável a ataques. Para proteger melhor suas contas contra grandes ocorrências de segurança, use a Proteção entre contas para receber alertas de segurança do Google. Ao receber esses eventos, você confere mudanças importantes na segurança da Conta do Google do usuário e pode tomar medidas no seu serviço para proteger suas contas.