Dodawanie uwierzytelniania wielopoziomowego TOTP do aplikacji na iOS

Jeśli masz już Firebase Authentication with Identity Platform, możesz dodać do swojej 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órego nie są właścicielami, 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 Apple SDK.

    MFA za pomocą TOTP jest obsługiwane tylko w pakiecie Apple SDK w wersji 10.12.0 i nowszej oraz tylko w systemie iOS.

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 i 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 (weryfikujący i sprawdzający) 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 te czynności:

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 (weryfikujący i sprawdzający) 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 w przypadku wszystkich użytkowników.

  • Podczas rejestracji zaproponuj opcję pominięcia rejestracji drugiego składnika. Jeśli chcesz zachęcić użytkowników 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 procesu 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.
guard let mfaSession = try? await currentUser.multiFactor.session() else { return }
guard let totpSecret = try? await TOTPMultiFactorGenerator.generateSecret(with: mfaSession) else { return }

// 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:
let 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(withQRCodeURL:):

    let otpAuthUri = totpSecret.generateQRCodeURL(
    withAccountName: currentUser.email ?? "default account",
    issuer: "Your App Name")
totpSecret.openInOTPApp(withQRCodeURL: otpAuthUri)

    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.
let verificationCode = // Code from user input.

// Finalize the enrollment.
let multiFactorAssertion = TOTPMultiFactorGenerator.assertionForEnrollment(
    with: totpSecret,
    oneTimePassword: verificationCode)
do {
    try await currentUser.multiFactor.enroll(
        with: multiFactorAssertion,
        displayName: "TOTP")
} catch {
    // Wrong or expired OTP. Re-prompt the user.
}

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 signIn(with...:) tak jak w przypadku, gdy nie używasz MFA (np. signIn(withEmail:password:)). Jeśli metoda zwróci błąd z kodem secondFactorRequired, uruchom przepływ MFA w swojej aplikacji.

    do {
    let authResult = try await Auth.auth().signIn(withEmail: email, password: password)

    // 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.)

    // ...
} catch let error as AuthErrorCode where error.code == .secondFactorRequired {
    // Initiate your second factor sign-in flow. (See next step.)
    // ...
} catch {
    // Other auth error.
    throw error
}

  2. Przepływ MFA w Twojej 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:

    let mfaKey = AuthErrorUserInfoMultiFactorResolverKey
guard let resolver = error.userInfo[mfaKey] as? MultiFactorResolver else { return }
let enrolledFactors = resolver.hints.map(\.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ę:

    let multiFactorInfo = resolver.hints[selectedIndex]
switch multiFactorInfo.factorID {
case TOTPMultiFactorID:
    let otpFromAuthenticator = // OTP typed by the user.
    let assertion = TOTPMultiFactorGenerator.assertionForSignIn(
        withEnrollmentID: multiFactorInfo.uid,
        oneTimePassword: otpFromAuthenticator)
    do {
        let authResult = try await resolver.resolveSignIn(with: assertion)
    } catch {
        // Wrong or expired OTP. Re-prompt the user.
    }
default:
    return
}

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:

guard let currentUser = Auth.auth().currentUser else { return }

// Prompt the user to select a factor to unenroll, from this array:
currentUser.multiFactor.enrolledFactors

// ...

// Unenroll the second factor.
let multiFactorInfo = currentUser.multiFactor.enrolledFactors[selectedIndex]
do {
    try await currentUser.multiFactor.unenroll(with: multiFactorInfo)
} catch let error as AuthErrorCode where error.code == .invalidUserToken {
    // Second factor unenrolled, but the user was signed out. Re-authenticate
    // them.
}

Co dalej?