El Acceso con Cuenta vinculada habilita el Acceso con Google con un solo toque para los usuarios que ya tienen su Cuenta de Google vinculada a tu servicio. Esto mejora el para los usuarios, ya que pueden acceder con un clic, sin tener que ingresar su nombre de usuario y contraseña. También reduce las posibilidades de que los usuarios creen cuentas duplicadas en tu servicio.
El Acceso con cuenta vinculada está disponible como parte del flujo de Acceso con One Tap para Android Esto significa que no necesitas importar una biblioteca aparte si la app ya tiene habilitada la función One Tap.
En este documento, aprenderás a modificar tu app para Android para que admita Acceso con cuenta vinculada.
Cómo funciona
- Aceptas mostrar las cuentas vinculadas durante el flujo de acceso con un solo toque.
- Si el usuario accedió a Google y vinculó su Cuenta de Google con su cuenta en tu servicio, se devolverá un token de ID para la cuenta de servicio predeterminada.
- Se le muestra al usuario un mensaje de acceso con One Tap con la opción de acceder a tu servicio con su cuenta vinculada.
- Si el usuario elige continuar con la cuenta vinculada, el token de ID del usuario se devuelve a tu app. Compara esto con el token que se envió a tu en el paso 2 para identificar al usuario que accedió.
Configuración
Configura tu entorno de desarrollo
Obtén las versiones más recientes de los Servicios de Google Play en tu host de desarrollo:
- Abre el Android SDK Manager.
En SDK Tools, busca Servicios de Google Play.
Si el estado de estos paquetes no es Instalado, selecciónalos y haz clic en Instalar paquetes
Cómo configurar tu app
En tu archivo
build.gradle
de nivel de proyecto, incluye el repositorio Maven de Google. en las seccionesbuildscript
yallprojects
.buildscript { repositories { google() } } allprojects { repositories { google() } }
Agregar las dependencias para "Vincular con Google" a la API de tu módulo archivo de Gradle a nivel de la app, que suele ser
app/build.gradle
:dependencies { implementation 'com.google.android.gms:play-services-auth:21.2.0' }
Modifica tu app para Android para admitir el acceso con cuenta vinculada
Al final del flujo de acceso a la cuenta vinculada, se devuelve un token de ID a tu . La integridad del token de ID se debe verificar antes de que acceda el usuario.
En el siguiente ejemplo de código, se detallan los pasos para recuperar, verificar el token de ID y, luego, permitir que el usuario acceda.
Crea una actividad para recibir el resultado del intent de acceso.
Kotlin
private val activityResultLauncher = registerForActivityResult( ActivityResultContracts.StartIntentSenderForResult()) { result -> if (result.resultCode == RESULT_OK) { try { val signInCredentials = Identity.signInClient(this) .signInCredentialFromIntent(result.data) // Review the Verify the integrity of the ID token section for // details on how to verify the ID token verifyIdToken(signInCredential.googleIdToken) } catch (e: ApiException) { Log.e(TAG, "Sign-in failed with error code:", e) } } else { Log.e(TAG, "Sign-in failed") } }
Java
private final ActivityResultLauncher<IntentSenderResult> activityResultLauncher = registerForActivityResult( new ActivityResultContracts.StartIntentSenderForResult(), result -> { If (result.getResultCode() == RESULT_OK) { try { SignInCredential signInCredential = Identity.getSignInClient(this) .getSignInCredentialFromIntent(result.getData()); verifyIdToken(signInCredential.getGoogleIdToken()); } catch (e: ApiException ) { Log.e(TAG, "Sign-in failed with error:", e) } } else { Log.e(TAG, "Sign-in failed") } });
Compila la solicitud de acceso
Kotlin
private val tokenRequestOptions = GoogleIdTokenRequestOptions.Builder() .supported(true) // Your server's client ID, not your Android client ID. .serverClientId(getString("your-server-client-id") .filterByAuthorizedAccounts(true) .associateLinkedAccounts("service-id-of-and-defined-by-developer", scopes) .build()
Java
private final GoogleIdTokenRequestOptions tokenRequestOptions = GoogleIdTokenRequestOptions.Builder() .setSupported(true) .setServerClientId("your-service-client-id") .setFilterByAuthorizedAccounts(true) .associateLinkedAccounts("service-id-of-and-defined-by-developer", scopes) .build()
Inicia el intent de acceso pendiente
Kotlin
Identity.signInClient(this) .beginSignIn( BeginSignInRequest.Builder() .googleIdTokenRequestOptions(tokenRequestOptions) .build()) .addOnSuccessListener{result -> activityResultLauncher.launch(result.pendingIntent.intentSender) } .addOnFailureListener {e -> Log.e(TAG, "Sign-in failed because:", e) }
Java
Identity.getSignInClient(this) .beginSignIn( BeginSignInRequest.Builder() .setGoogleIdTokenRequestOptions(tokenRequestOptions) .build()) .addOnSuccessListener(result -> { activityResultLauncher.launch( result.getPendingIntent().getIntentSender()); }) .addOnFailureListener(e -> { Log.e(TAG, "Sign-in failed because:", e); });
Verifica la integridad del token de ID
Para verificar que el token sea válido, asegúrate de que se cumplan los siguientes requisitos: se cumplen los siguientes criterios:
- Google debe firmar correctamente el token de ID. Usa las claves públicas de Google
(disponible en
JWK o
PEM)
para verificar la firma del token. Estas claves se rotan con regularidad; examinar
el encabezado
Cache-Control
en la respuesta para determinar cuándo deberías recuperarlos de nuevo. - El valor de
aud
en el token de ID es igual a uno de los IDs de cliente. Esta comprobación es necesaria para prevenir tokens de ID emitidos a un app que se usa para acceder a los datos del mismo usuario en el servidor de backend de tu app. - El valor de
iss
en el token de ID es igual aaccounts.google.com
ohttps://accounts.google.com
. - No pasó la hora de vencimiento (
exp
) del token de ID. - Si necesitas validar que el token de ID represente un espacio de nombres de Google Workspace o Cloud
de tu organización, puedes verificar la reclamación de
hd
, que indica el estado dominio del usuario. Se debe usar cuando se restringe el acceso a un recurso a solo los miembros del determinados dominios. La ausencia de este reclamo indica que la cuenta no pertenece a un Dominio alojado en Google.
Usa los campos email
, email_verified
y hd
para determinar si
Google aloja una dirección de correo electrónico y tiene la autoridad para hacerlo. En los casos en que Google tenga autoridad,
se sabe que el usuario es el propietario legítimo de la cuenta, por lo que puedes omitir la contraseña u otra
de verificación de identidad.
Casos en los que Google es confiable:
email
tiene el sufijo@gmail.com
; esta es una cuenta de Gmail.email_verified
es verdadero yhd
está configurado. Esta es una cuenta de G Suite.
Los usuarios pueden registrarse en Cuentas de Google sin usar Gmail ni G Suite. Cuándo
email
no contiene un sufijo @gmail.com
y hd
está ausente; Google no lo hace
se recomienda verificar con métodos de verificación, tanto confiables como con contraseñas
del usuario. email_verified
también puede ser verdadero, ya que Google verificó inicialmente el
usuario cuando se creó la cuenta de Google, sin embargo, la propiedad del tercero
de correo electrónico puede haber cambiado desde entonces.
En lugar de escribir tu propio código para realizar estos pasos de verificación, te recomendamos
recomendamos usar una biblioteca cliente de API de Google para tu plataforma o una biblioteca
biblioteca JWT. Para desarrollo y depuración, puedes llamar a nuestro tokeninfo
.
extremo de validación.
Usa una biblioteca cliente de la API de Google
Con el Biblioteca cliente de la API de Google para Java es la forma recomendada de validar tokens de ID de Google en un entorno de producción.
Java
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.");
}
El método GoogleIdTokenVerifier.verify()
verifica la firma de JWT, el
El reclamo de aud
, el reclamo de iss
y el reclamo de exp
.
Si necesitas validar que el token de ID representa una cuenta de organización de Google Workspace o Cloud, puedes verificar el reclamo hd
verificando el nombre de dominio que muestra el método Payload.getHostedDomain()
.
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.