Accesso all'account collegato per Android

L'accesso con un account collegato attiva l'opzione Accedi con Google One Tap per gli utenti che hanno già il proprio Account Google collegato al tuo servizio. Ciò migliora esperienza utente, in quanto possono accedere con un solo clic, senza dover nome utente e password. Riducono anche le possibilità che gli utenti creino duplicati nel tuo servizio.

L'accesso con un account collegato è disponibile nell'ambito del flusso di accesso One Tap per Android. Ciò significa che non devi importare una libreria separata se la funzionalità One Tap è già attivata nella tua app.

In questo documento scoprirai come modificare la tua app per Android in modo da supportare l'accesso con l'account collegato.

Come funziona

  1. Attiva la visualizzazione degli account collegati durante il flusso di accesso con un solo tocco.
  2. Se l'utente ha eseguito l'accesso su Google e ha collegato il proprio Account Google a il proprio account sul tuo servizio, verrà restituito un token ID per .
  3. L'utente visualizza una richiesta di accesso One Tap con un'opzione per accedere al tuo con il proprio account collegato.
  4. Se l'utente sceglie di continuare con l'account collegato, il token ID dell'utente viene restituito nella tua app. Devi confrontare questa informazione con il token inviato al tuo server nel passaggio 2 per identificare l'utente che ha eseguito l'accesso.

Configurazione

Configurazione dell'ambiente di sviluppo

Scarica la versione più recente di Google Play Services sull'host di sviluppo:

  1. Apri l'app Gestione SDK Android.
di Gemini Advanced.

  1. In Strumenti SDK, individua Google Play Services.

  2. Se lo stato di questi pacchetti non è installato, selezionali entrambi e fai clic su Installa pacchetti.

Configura la tua app

  1. Nel file build.gradle a livello di progetto, includi il repository Maven di Google sia nelle sezioni buildscript che allprojects.

    buildscript {
    repositories {
        google()
    }
}

allprojects {
    repositories {
        google()
    }
}

  2. Aggiungi le dipendenze per l'API "Collega con Google" al file Gradle a livello di app del tuo modulo, che in genere è app/build.gradle:

    dependencies {
  implementation 'com.google.android.gms:play-services-auth:21.2.0'
}

Modificare l'app per Android in modo che supporti l'accesso all'account collegato

Al termine del flusso di accesso all'account collegato, viene restituito un token ID al tuo dell'app. L'integrità del token ID deve essere verificata prima di eseguire l'accesso dell'utente.

Il seguente esempio di codice descrive in dettaglio i passaggi da recuperare. verificare il token ID e successivamente far eseguire l'accesso all'utente.

  1. Crea un'attività per ricevere il risultato dell'intento di accesso

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

  2. Crea la richiesta di accesso

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

  3. Lancia l'intent in attesa di accesso

    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 l'integrità del token ID

Per verificare che il token sia valido, assicurati che: vengono soddisfatti i seguenti criteri:

  • Il token ID sia stato firmato correttamente da Google. Utilizza le chiavi pubbliche di Google (disponibile in JWK o PEM) per verificare la firma del token. Queste chiavi vengono ruotate regolarmente, esaminare l'intestazione Cache-Control nella risposta per determinare quando dovresti recuperarli di nuovo.
  • Il valore di aud nel token ID è uguale a uno dei gli ID cliente. Questo controllo è necessario per evitare token ID emessi da un utente malintenzionato dell'app utilizzata per accedere ai dati relativi allo stesso utente sul server di backend dell'app.
  • Il valore di iss nel token ID è uguale a accounts.google.com o https://accounts.google.com.
  • La data di scadenza (exp) del token ID non è trascorsa.
  • Se devi confermare che il token ID rappresenta un account Google Workspace o Cloud dell'organizzazione, puoi controllare la rivendicazione hd, che indica la presenza di dominio dell'utente. Deve essere usato quando limiti l'accesso a una risorsa ai soli membri di determinati domini. L'assenza di questa rivendicazione indica che l'account non appartiene a un Dominio ospitato da Google.

Utilizzando i campi email, email_verified e hd, puoi determinare se Google ospita un indirizzo email ed è autorevole. Nei casi in cui Google è autorevole, è noto per essere il legittimo proprietario dell'account e puoi saltare l'uso della password metodi di verifica.

Casi in cui Google è autorevole:

  • email ha un suffisso @gmail.com, questo è un account Gmail.
  • email_verified è true e hd è impostato, questo è un account G Suite.

Gli utenti possono registrarsi per creare Account Google senza utilizzare Gmail o G Suite. Quando email non contiene un suffisso @gmail.com e hd non è presente; Google non autoritativi e con password o altri metodi di verifica per verificare per l'utente. Il valore email_verified può anche essere vero perché Google ha verificato inizialmente il valore all'utente quando è stato creato l'account Google, ma la proprietà della terza parte l'account email potrebbe essere cambiato da allora.

Anziché scrivere il tuo codice per eseguire questi passaggi di verifica, ti consigliamo consigliamo di utilizzare una libreria client API di Google per la tua piattaforma o un nella libreria JWT. Per lo sviluppo e il debug, puoi chiamare il nostro tokeninfo endpoint di convalida.

Utilizzare una libreria client dell'API di Google

L'utilizzo del Libreria client dell'API di Google per Java è il metodo consigliato per convalidare i token ID Google in un ambiente di produzione.

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

Il metodo GoogleIdTokenVerifier.verify() verifica la firma JWT, l'attributo aud, l'attributo iss e l'attributo exp.

Se devi confermare che il token ID rappresenta un account Google Workspace o Cloud account dell'organizzazione, puoi verificare la rivendicazione hd controllando il nome di dominio restituito dal metodo Payload.getHostedDomain().

Chiamata all'endpoint tokeninfo

Un modo semplice per convalidare la firma di un token ID per il debug è: usa l'endpoint tokeninfo. La chiamata a questo endpoint prevede un richiesta di rete aggiuntiva che esegue la maggior parte della convalida, mentre la convalida e l’estrazione del payload nel tuo codice. Non è adatto per l'uso in produzione poiché le richieste potrebbero essere limitate o comunque soggette a errori intermittenti.

Per convalidare un token ID utilizzando l'endpoint tokeninfo, crea un protocollo HTTPS POST o GET all'endpoint e trasmetti il token ID id_token. Ad esempio, per convalidare il token "XYZ123", effettua la seguente richiesta GET:

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

Se il token è firmato correttamente e iss e exp che le attestazioni hanno i valori previsti, si riceverà una risposta HTTP 200, in cui il corpo contiene le attestazioni dei token ID in formato JSON. Ecco un esempio di risposta:

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

Se devi verificare che il token ID rappresenti un account Google Workspace, puoi controllare la rivendicazione hd, che indica il dominio ospitato dell'utente. Deve essere utilizzata quando limitare l'accesso a una risorsa ai soli membri di determinati domini. L'assenza di questa dichiarazione indica che l'account non appartiene a un dominio ospitato da Google Workspace.