Dodawanie uwierzytelniania wielopoziomowego TOTP do aplikacji na Androida

Jeśli masz już usługę Firebase Authentication with Identity Platform, możesz dodać do aplikacji uwierzytelnianie wielopoziomowe (MFA) za pomocą haseł jednorazowych opartych na czasie (TOTP).

Firebase Authentication with Identity Platform umożliwia używanie TOTP jako dodatkowego składnika MFA. Gdy włączysz tę funkcję, użytkownicy próbujący zalogować się w Twojej aplikacji zobaczą prośbę o podanie TOTP. Aby je wygenerować, muszą użyć aplikacji uwierzytelniającej, która potrafi generować prawidłowe kody TOTP, np. Google Authenticator.

Zanim zaczniesz

  1. Włącz co najmniej 1 dostawcę, który obsługuje MFA. Pamiętaj, że MFA jest obsługiwane przez wszystkich dostawców z wyjątkiem tych:

    • Uwierzytelnianie przez telefon
    • Anonimowe uwierzytelnianie
    • Niestandardowe tokeny uwierzytelniania
    • Apple Game Center

  2. Upewnij się, że Twoja aplikacja weryfikuje adresy e-mail użytkowników. MFA wymaga weryfikacji adresu e-mail. Zapobiega to rejestrowaniu się w usłudze przez złośliwych użytkowników za pomocą adresu e-mail, który nie należy do nich, a następnie blokowaniu dostępu do tego adresu e-mail przez dodanie drugiego składnika.

  3. Jeśli jeszcze tego nie zrobisz, zainstaluj pakiet Firebase Android SDK.

    MFA za pomocą TOTP jest obsługiwane tylko w pakiecie Android SDK w wersji 22.1.0 lub nowszej.

Włączanie MFA za pomocą TOTP

Aby włączyć TOTP jako drugi składnik, użyj Admin SDK lub wywołaj punkt końcowy REST konfiguracji projektu.

Aby używać pak0/}, wykonaj te czynności:Admin SDK

  1. Jeśli jeszcze tego nie zrobisz, zainstaluj pakiet Firebase Admin Node.js SDK.

    MFA za pomocą TOTP jest obsługiwane tylko w pakiecie Firebase Admin Node.js SDK w wersji 11.6.0 lub nowszej.

  2. Wykonaj zapytanie:

    import { getAuth } from 'firebase-admin/auth';

getAuth().projectConfigManager().updateProjectConfig(
{
      multiFactorConfig: {
          providerConfigs: [{
              state: "ENABLED",
              totpProviderConfig: {
                  adjacentIntervals: NUM_ADJ_INTERVALS
              }
          }]
      }
})

    Zastąp następujące elementy:

    • NUM_ADJ_INTERVALS: liczba sąsiednich przedziałów czasu, z których mają być akceptowane TOTP, od zera do dziesięciu. Domyślna wartość to 5.

      TOTP działają w ten sposób, że gdy 2 strony (prover i validator) generują hasła jednorazowe w tym samym przedziale czasu (zwykle 30 sekund), generują to samo hasło. Aby jednak uwzględnić różnice w czasie między stronami i czas reakcji człowieka, możesz skonfigurować usługę TOTP tak, aby akceptowała też TOTP z sąsiednich okien.

Aby włączyć MFA za pomocą TOTP przy użyciu interfejsu REST API, wykonaj to polecenie:

curl -X PATCH "https://identitytoolkit.googleapis.com/admin/v2/projects/PROJECT_ID/config?updateMask=mfa" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: PROJECT_ID" \
    -d \
    '{
        "mfa": {
          "providerConfigs": [{
            "state": "ENABLED",
            "totpProviderConfig": {
              "adjacentIntervals": NUM_ADJ_INTERVALS
            }
          }]
       }
    }'

Zastąp następujące elementy:

  • PROJECT_ID: identyfikator projektu.

  • NUM_ADJ_INTERVALS: liczba przedziałów czasu, od zera do dziesięciu. Domyślna wartość to 5.

    TOTP działają w ten sposób, że gdy 2 strony (prover i validator) generują hasła jednorazowe w tym samym przedziale czasu (zwykle 30 sekund), generują to samo hasło. Aby jednak uwzględnić różnice w czasie między stronami i czas reakcji człowieka, możesz skonfigurować usługę TOTP tak, aby akceptowała też TOTP z sąsiednich okien.

Wybieranie wzorca rejestracji

Możesz wybrać, czy Twoja aplikacja wymaga uwierzytelniania wielopoziomowego, a także jak i kiedy rejestrować użytkowników. Oto kilka typowych wzorców:

  • Zarejestruj drugi składnik użytkownika w ramach rejestracji. Użyj tej metody, jeśli Twoja aplikacja wymaga uwierzytelniania wielopoziomowego od wszystkich użytkowników.

  • Podczas rejestracji zaproponuj opcję pominięcia rejestracji drugiego składnika. Jeśli chcesz zachęcać do korzystania z uwierzytelniania wielopoziomowego w swojej aplikacji, ale nie chcesz go wymagać, możesz zastosować to podejście.

  • Zamiast na ekranie rejestracji umożliw użytkownikom dodawanie drugiego składnika na stronie zarządzania kontem lub profilem. Minimalizuje to trudności podczas rejestracji, a jednocześnie udostępnia uwierzytelnianie wielopoziomowe użytkownikom, którzy dbają o bezpieczeństwo.

  • Wymagaj dodania drugiego składnika stopniowo, gdy użytkownik chce uzyskać dostęp do funkcji o zwiększonych wymaganiach dotyczących bezpieczeństwa.

Rejestrowanie użytkowników w MFA za pomocą TOTP

Gdy włączysz MFA za pomocą TOTP jako drugi składnik w swojej aplikacji, zaimplementuj logikę po stronie klienta, aby zarejestrować użytkowników w MFA za pomocą TOTP:

  1. Ponownie uwierzytelnij użytkownika.

  2. Wygeneruj tajny klucz TOTP dla uwierzytelnionego użytkownika:

    // Generate a TOTP secret.
Firebase.auth.currentUser.multiFactor.session
    .addOnSuccessListener { multiFactorSession ->
        TotpMultiFactorGenerator.generateSecret(multiFactorSession)
            .addOnSuccessListener { totpSecret ->
                // Display the secret to the user and prompt them to
                // enter it into their authenticator app. (See the next
                // step.)
            }
    }

  3. Wyświetl tajny klucz użytkownikowi i poproś go o wpisanie go w aplikacji uwierzytelniającej:

    // Display this key:
val secret = totpSecret.sharedSecretKey

    Oprócz wyświetlania tajnego klucza możesz spróbować automatycznie dodać go do domyślnej aplikacji uwierzytelniającej na urządzeniu. Aby to zrobić, wygeneruj identyfikator URI klucza zgodny z Google Authenticator, i przekaż go do openInOtpApp():

    val qrCodeUri = totpSecret.generateQrCodeUrl(
    currentUser.email ?: "default account",
    "Your App Name")
totpSecret.openInOtpApp(qrCodeUri)

    Gdy użytkownik doda tajny klucz do aplikacji uwierzytelniającej, zacznie ona generować TOTP.

  4. Poproś użytkownika o wpisanie TOTP wyświetlanego przez aplikację uwierzytelniającą i użycie go do dokończenia rejestracji w MFA:

    // Ask the user for a verification code from the authenticator app.
val verificationCode = // Code from user input.

// Finalize the enrollment.
val multiFactorAssertion = TotpMultiFactorGenerator
    .getAssertionForEnrollment(totpSecret, verificationCode)
Firebase.auth.currentUser.multiFactor.enroll(multiFactorAssertion, "TOTP")
    .addOnSuccessListener {
        // Enrollment complete.
    }

Logowanie użytkowników za pomocą drugiego składnika

Aby logować użytkowników za pomocą MFA za pomocą TOTP, użyj tego kodu:

  1. Wywołaj jedną z metod signInWith- tak jak w przypadku, gdy nie używasz MFA. (Na przykład signInWithEmailAndPassword().) Jeśli metoda zgłosi wyjątek FirebaseAuthMultiFactorException, uruchom przepływ MFA w aplikacji.

    Firebase.auth.signInWithEmailAndPassword(email, password)
    .addOnSuccessListener { result ->
        // If the user is not enrolled with a second factor and provided valid
        // credentials, sign-in succeeds.

        // (If your app requires MFA, this could be considered an error
        // condition, which you would resolve by forcing the user to enroll a
        // second factor.)

        // ...
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthMultiFactorException -> {
                // Initiate your second factor sign-in flow. (See next step.)
                // ...
            }
        }
    }

  2. Przepływ MFA w aplikacji powinien najpierw poprosić użytkownika o wybranie drugiego składnika, którego chce użyć. Listę obsługiwanych drugich składników możesz uzyskać, sprawdzając właściwość hints instancji MultiFactorResolver:

    val enrolledFactors = exception.resolver.hints.map { it.displayName }

  3. Jeśli użytkownik zdecyduje się użyć TOTP, poproś go o wpisanie TOTP wyświetlanego w aplikacji uwierzytelniającej i użycie go do zalogowania się:

    when (exception.resolver.hints[selectedIndex].factorId) {
    TotpMultiFactorGenerator.FACTOR_ID -> {
        val otpFromAuthenticator = // OTP typed by the user.
        val assertion = TotpMultiFactorGenerator.getAssertionForSignIn(
            exception.resolver.hints[selectedIndex].uid,
            otpFromAuthenticator
        )
        exception.resolver.resolveSignIn(assertion)
            .addOnSuccessListener { result ->
                // Successfully signed in!
            }
            .addOnFailureListener { resolveError ->
                // Invalid or expired OTP.
            }
    }
    PhoneMultiFactorGenerator.FACTOR_ID -> {
        // Handle SMS second factor.
    }
}

Wyrejestrowywanie się z MFA za pomocą TOTP

W tej sekcji opisujemy, jak obsługiwać wyrejestrowywanie się użytkownika z MFA za pomocą TOTP.

Jeśli użytkownik zarejestrował się w kilku opcjach MFA i wyrejestruje się z ostatnio włączonej opcji, otrzyma komunikat auth/user-token-expired i zostanie wylogowany. Użytkownik musi zalogować się ponownie i zweryfikować swoje dotychczasowe dane logowania, np. adres e-mail i hasło.

Aby wyrejestrować użytkownika, obsłużyć błąd i wywołać ponowne uwierzytelnienie, użyj tego kodu:

Firebase.auth.currentUser.multiFactor.unenroll(mfaEnrollmentId)
    .addOnSuccessListener {
        // Second factor unenrolled.
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthInvalidUserException -> {
                // Second factor unenrolled. If the user was signed out, re-authenticate
                // them.

                // For example, if they signed in with a password, prompt them to
                // provide it again, then call `reauthenticateWithCredential()` as shown
                // below.
                val credential = EmailAuthProvider.getCredential(email, password)
                currentUser.reauthenticate(credential)
                    .addOnSuccessListener { 
                        // Success!
                    }
                    .addOnFailureListener { 
                        // Bad email address and password combination.
                    }
            }
        }
    }

Co dalej?