Autenticazione con OpenID Connect su Android

Se hai eseguito l'upgrade a Firebase Authentication with Identity Platform, puoi autenticare i tuoi utenti con Firebase utilizzando il provider conforme a OpenID Connect (OIDC) di tua scelta. In questo modo è possibile utilizzare provider di identità non supportati in modo nativo da Firebase.

Prima di iniziare

Per consentire l'accesso degli utenti utilizzando un provider OIDC, devi prima raccogliere alcune informazioni dal provider:

  • ID client: una stringa univoca per il fornitore che identifica la tua app. Il tuo fornitore potrebbe assegnarti un ID client diverso per ogni piattaforma che supporti. Si tratta di uno dei valori dell'attestazione aud nei token ID emessi dal tuo provider.

  • Client secret: una stringa segreta che il fornitore utilizza per confermare la proprietà di un ID client. Per ogni ID client, avrai bisogno di un client secret corrispondente. (Questo valore è obbligatorio solo se utilizzi il flusso di codice di autorizzazione, che è vivamente consigliato.)

  • Emittente: una stringa che identifica il tuo fornitore. Questo valore deve essere un URL che, se aggiunto a /.well-known/openid-configuration, corrisponde alla posizione del documento di rilevamento OIDC del fornitore. Ad esempio, se l'emittente è https://auth.example.com, il documento di rilevamento deve essere disponibile all'indirizzo https://auth.example.com/.well-known/openid-configuration.

Una volta ottenute le informazioni sopra indicate, abilita OpenID Connect come provider di accesso per il tuo progetto Firebase:

  1. Aggiungi Firebase al tuo progetto Android.

  2. Se non hai eseguito l'upgrade a Firebase Authentication with Identity Platform, fallo ora. L'autenticazione OpenID Connect è disponibile solo nei progetti di cui è stato eseguito l'upgrade.

  3. Nella pagina Provider di accesso della console Firebase, fai clic su Aggiungi nuovo provider e poi su OpenID Connect.

  4. Seleziona se utilizzerai il flusso del codice di autorizzazione o il flusso di concessione implicita.

    Se il tuo provider lo supporta, devi sempre utilizzare il flusso di codice. Il flusso implicito è meno sicuro e il suo utilizzo è fortemente sconsigliato.

  5. Assegna un nome a questo fornitore. Prendi nota dell'ID provider generato: ad esempio oidc.example-provider. Ti servirà questo ID quando aggiungi il codice di accesso alla tua app.

  6. Specifica l'ID client, il client secret e la stringa dell'emittente del provider. Questi valori devono corrispondere esattamente a quelli assegnati dal tuo fornitore.

  7. Salva le modifiche.

Gestire il flusso di accesso con l'SDK Firebase

Se stai creando un'app per Android, il modo più semplice per autenticare gli utenti con Firebase utilizzando il tuo provider OIDC è gestire l'intero flusso di accesso con l'SDK Firebase per Android.

Per gestire il flusso di accesso con l'SDK Firebase per Android, segui questi passaggi:

  1. Crea un'istanza di OAuthProvider utilizzando il relativo Builder con l'ID del provider.

    Kotlin 

    val providerBuilder = OAuthProvider.newBuilder("oidc.example-provider")

    Java 

    OAuthProvider.Builder providerBuilder = OAuthProvider.newBuilder("oidc.example-provider");

  2. (Facoltativo) Specifica parametri OAuth personalizzati aggiuntivi che vuoi inviare con la richiesta OAuth.

    Kotlin 

    // Target specific email with login hint.
providerBuilder.addCustomParameter("login_hint", "user@example.com")

    Java 

    // Target specific email with login hint.
providerBuilder.addCustomParameter("login_hint", "user@example.com");

    Verifica con il tuo fornitore OIDC i parametri che supporta. Tieni presente che non puoi trasmettere i parametri richiesti da Firebase con setCustomParameters(). Questi parametri sono client_id, response_type, redirect_uri, state, scope e response_mode.

  3. (Facoltativo): specifica ambiti OAuth 2.0 aggiuntivi oltre al profilo di base che vuoi richiedere al fornitore di autenticazione.

    Kotlin 

    // Request read access to a user's email addresses.
// This must be preconfigured in the app's API permissions.
providerBuilder.scopes = listOf("mail.read", "calendars.read")

    Java 

    // Request read access to a user's email addresses.
// This must be preconfigured in the app's API permissions.
List<String> scopes =
        new ArrayList<String>() {
            {
                add("mail.read");
                add("calendars.read");
            }
        };
providerBuilder.setScopes(scopes);

    Rivolgiti al tuo fornitore OIDC per conoscere gli ambiti che utilizza.

  4. Esegui l'autenticazione con Firebase utilizzando l'oggetto del provider OAuth. Tieni presente che, a differenza di altre operazioni di FirebaseAuth, questa operazione prenderà il controllo della tua UI visualizzando una scheda personalizzata di Chrome. Di conseguenza, non fare riferimento alla tua attività in OnSuccessListener e OnFailureListener che alleghi, in quanto verranno immediatamente staccati quando l'operazione avvia la UI.

    Per prima cosa, controlla se hai già ricevuto una risposta. L'accesso con questo metodo mette l'attività in background, il che significa che può essere recuperata dal sistema durante il flusso di accesso. Per evitare che l'utente debba riprovare in caso di errore, controlla se è già presente un risultato.

    Per verificare se è presente un risultato in attesa, chiama il numero getPendingAuthResult:

    Kotlin 

    val pendingResultTask = firebaseAuth.pendingAuthResult
if (pendingResultTask != null) {
    // There's something already here! Finish the sign-in for your user.
    pendingResultTask
        .addOnSuccessListener {
            // User is signed in.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
            // The OAuth secret can be retrieved by calling:
            // ((OAuthCredential)authResult.getCredential()).getSecret().
        }
        .addOnFailureListener {
            // Handle failure.
        }
} else {
    // There's no pending result so you need to start the sign-in flow.
    // See below.
}

    Java 

    Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
if (pendingResultTask != null) {
    // There's something already here! Finish the sign-in for your user.
    pendingResultTask
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // User is signed in.
                            // IdP data available in
                            // authResult.getAdditionalUserInfo().getProfile().
                            // The OAuth access token can also be retrieved:
                            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                            // The OAuth secret can be retrieved by calling:
                            // ((OAuthCredential)authResult.getCredential()).getSecret().
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });
} else {
    // There's no pending result so you need to start the sign-in flow.
    // See below.
}

    Per avviare il flusso di accesso, chiama startActivityForSignInWithProvider:

    Kotlin 

    firebaseAuth
    .startActivityForSignInWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // User is signed in.
        // IdP data available in
        // authResult.getAdditionalUserInfo().getProfile().
        // The OAuth access token can also be retrieved:
        // ((OAuthCredential)authResult.getCredential()).getAccessToken().
        // The OAuth secret can be retrieved by calling:
        // ((OAuthCredential)authResult.getCredential()).getSecret().
    }
    .addOnFailureListener {
        // Handle failure.
    }

    Java 

    firebaseAuth
        .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // User is signed in.
                        // IdP data available in
                        // authResult.getAdditionalUserInfo().getProfile().
                        // The OAuth access token can also be retrieved:
                        // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                        // The OAuth secret can be retrieved by calling:
                        // ((OAuthCredential)authResult.getCredential()).getSecret().
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });

  5. Mentre gli esempi precedenti si concentrano sui flussi di accesso, hai anche la possibilità di collegare un provider OIDC a un utente esistente utilizzando startActivityForLinkWithProvider. Ad esempio, puoi collegare più provider allo stesso utente, consentendogli di accedere con uno qualsiasi.

    Kotlin 

    // The user is already signed-in.
val firebaseUser = firebaseAuth.currentUser!!
firebaseUser
    .startActivityForLinkWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // Provider credential is linked to the current user.
        // IdP data available in
        // authResult.getAdditionalUserInfo().getProfile().
        // The OAuth access token can also be retrieved:
        // authResult.getCredential().getAccessToken().
        // The OAuth secret can be retrieved by calling:
        // authResult.getCredential().getSecret().
    }
    .addOnFailureListener {
        // Handle failure.
    }

    Java 

    // The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
        .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // Provider credential is linked to the current user.
                        // IdP data available in
                        // authResult.getAdditionalUserInfo().getProfile().
                        // The OAuth access token can also be retrieved:
                        // authResult.getCredential().getAccessToken().
                        // The OAuth secret can be retrieved by calling:
                        // authResult.getCredential().getSecret().
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });

  6. Lo stesso pattern può essere utilizzato con startActivityForReauthenticateWithProvider, che può essere utilizzato per recuperare credenziali aggiornate per operazioni sensibili che richiedono un accesso recente.

    Kotlin 

    // The user is already signed-in.
val firebaseUser = firebaseAuth.currentUser!!
firebaseUser
    .startActivityForReauthenticateWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // User is re-authenticated with fresh tokens and
        // should be able to perform sensitive operations
        // like account deletion and email or password
        // update.
    }
    .addOnFailureListener {
        // Handle failure.
    }

    Java 

    // The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
        .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // User is re-authenticated with fresh tokens and
                        // should be able to perform sensitive operations
                        // like account deletion and email or password
                        // update.
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });

Gestire manualmente il flusso di accesso

Se hai già implementato il flusso di accesso OpenID Connect nella tua app, puoi utilizzare il token ID direttamente per l'autenticazione con Firebase:

Kotlin 

val providerId = "oidc.example-provider" // As registered in Firebase console.
val credential = oAuthCredential(providerId) {
    setIdToken(idToken) // ID token from OpenID Connect flow.
}
Firebase.auth
    .signInWithCredential(credential)
    .addOnSuccessListener { authResult ->
        // User is signed in.

        // IdP data available in:
        //    authResult.additionalUserInfo.profile
    }
    .addOnFailureListener { e ->
        // Handle failure.
    }

Java 

AuthCredential credential = OAuthProvider
        .newCredentialBuilder("oidc.example-provider")  // As registered in Firebase console.
        .setIdToken(idToken)  // ID token from OpenID Connect flow.
        .build();
FirebaseAuth.getInstance()
        .signInWithCredential(credential)
        .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
                // User is signed in.

                // IdP data available in:
                //    authResult.getAdditionalUserInfo().getProfile()
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Handle failure.
            }
        });

Passaggi successivi

Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente e collegato alle credenziali, ovvero nome utente e password, numero di telefono o informazioni del fornitore di autenticazione, con cui l'utente ha eseguito l'accesso. Questo nuovo account viene memorizzato come parte del tuo progetto Firebase e può essere utilizzato per identificare un utente in ogni app del tuo progetto, indipendentemente dalla modalità di accesso.

  • Nelle tue app, puoi ottenere le informazioni di base del profilo dell'utente dall'oggetto FirebaseUser. Vedi Gestire gli utenti.

  • Nelle regole di sicurezza di Firebase Realtime Database e Cloud Storage, puoi ottenere l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.

Puoi consentire agli utenti di accedere alla tua app utilizzando più provider di autenticazione collegando le credenziali del provider di autenticazione a un account utente esistente.

Per disconnettere un utente, chiama signOut:

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();