Autentica con un servidor de backend

Si usas el Acceso con Google en una app o sitio que se comunica con un servidor de backend, es posible que debas identificar al usuario con una sesión activa en el servidor. Para hacerlo de manera segura, después de que un usuario acceda correctamente, envía el token de ID del usuario a tu servidor mediante HTTPS. Luego, en el servidor, verifica la integridad del token de ID y usa la información del usuario que este contiene para establecer una sesión o crear una cuenta nueva.

Envía el token de ID a tu servidor

Primero, cuando el usuario acceda, obtén su token de ID:

  1. Cuando configures el Acceso con Google, llama al método requestIdToken y pásale el ID de cliente web del servidor.

    // 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();
  2. Cuando se inicie tu app, verifica si el usuario ya accedió a tu app con Google, en este o en otro dispositivo, llamando a silentSignIn:

    GoogleSignIn.silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                handleSignInResult(task);
              }
            });
  3. Si el usuario no puede acceder de forma silenciosa, presenta tu experiencia normal cuando sale de su cuenta y proporciónale la opción de acceder. Cuando el usuario acceda, obtén su GoogleSignInAccount en el resultado de la actividad del intent de acceso:

    // This task is always completed immediately, there is no need to attach an
    // asynchronous listener.
    Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data);
    handleSignInResult(task);
  4. Después de que el usuario acceda de forma silenciosa o explícita, obtén el token de ID desde el objeto 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);
        }
    }

Luego, envía el token de ID a tu servidor con una solicitud 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);
}

Verifica la integridad del token de ID

Después de recibir el token de ID mediante HTTPS POST, debes verificar su integridad.

To verify that the token is valid, ensure that the following criteria are satisfied:

  • The ID token is properly signed by Google. Use Google's public keys (available in JWK or PEM format) to verify the token's signature. These keys are regularly rotated; examine the Cache-Control header in the response to determine when you should retrieve them again.
  • The value of aud in the ID token is equal to one of your app's client IDs. This check is necessary to prevent ID tokens issued to a malicious app being used to access data about the same user on your app's backend server.
  • The value of iss in the ID token is equal to accounts.google.com or https://accounts.google.com.
  • The expiry time (exp) of the ID token has not passed.
  • 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.

Using the email, email_verified and hd fields, you can determine if Google hosts and is authoritative for an email address. In the cases where Google is authoritative, the user is known to be the legitimate account owner, and you may skip password or other challenge methods.

Cases where Google is authoritative:

  • email has a @gmail.com suffix, this is a Gmail account.
  • email_verified is true and hd is set, this is a G Suite account.

Users may register for Google Accounts without using Gmail or G Suite. When email does not contain a @gmail.com suffix and hd is absent, Google is not authoritative and password or other challenge methods are recommended to verify the user. email_verified can also be true as Google initially verified the user when the Google account was created, however ownership of the third party email account may have since changed.

Rather than writing your own code to perform these verification steps, we strongly recommend using a Google API client library for your platform, or a general-purpose JWT library. For development and debugging, you can call our tokeninfo validation endpoint.

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

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

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' => $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
}

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

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.

Llama al extremo de tokeninfo

Una manera sencilla de validar la firma de un token de ID para la depuración es usa el extremo tokeninfo. Llamar a este extremo implica una solicitud de red adicional que realice la mayor parte de la validación por ti mientras pruebas las y la extracción de cargas útiles en tu propio código. No es apto para uso en producción código, ya que las solicitudes pueden ser limitadas o estar sujetas a errores intermitentes.

Para validar un token de ID con el extremo tokeninfo, crea un protocolo HTTPS POST o GET al extremo y pasa tu token de ID en el Parámetro id_token. Por ejemplo, para validar el token “XYZ123”, realiza la siguiente solicitud GET:

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

Si el token está firmado correctamente, y iss y exp tienen los valores esperados, recibirás una respuesta HTTP 200, contiene las reclamaciones de tokens de ID con formato JSON. Esta es una respuesta de ejemplo:

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

Si necesitas validar que el token de ID representa una cuenta de Google Workspace, puedes verificarlo. La reclamación hd, que indica el dominio alojado del usuario Se debe usar cuando restringir el acceso a un recurso únicamente a los miembros de ciertos dominios. La ausencia de este reclamo indica que la cuenta no pertenece a un dominio alojado de Google Workspace.

Crea una cuenta o sesión

Después de verificar el token, comprueba si el usuario ya se encuentra en tu base de datos de usuarios. De ser así, establece una sesión autenticada para el usuario. Si el usuario aún no se encuentra en tu base de datos, crea un registro de usuario nuevo a partir de la información de la carga útil del token de ID y establece una sesión para el usuario. Puedes solicitarle al usuario cualquier información de perfil adicional que necesites cuando detectas un usuario recién creado en tu app.

Cómo proteger las cuentas de tus usuarios con la Protección integral de la cuenta

Si dependes de Google para que un usuario acceda, te beneficiarás automáticamente de todas las funciones de seguridad y la infraestructura que Google creó para proteger los datos del usuario. Sin embargo, en el caso improbable de que la Cuenta de Google del usuario se vea comprometida o de que se produzca algún otro evento de seguridad importante, tu app también podría ser vulnerable a ataques. Para proteger mejor tus cuentas de cualquier evento de seguridad importante, usa la Protección integral de la cuenta para recibir alertas de seguridad de Google. Cuando recibes estos eventos, obtienes visibilidad de los cambios importantes en la seguridad de la Cuenta de Google del usuario y puedes tomar medidas en el servicio para proteger tus cuentas.