Multi-Faktor-Authentifizierung für Ihre Android-App hinzufügen

In diesem Artikel erfahren Sie, wie Sie einer Android-App die SMS-Multi-Faktor-Authentifizierung hinzufügen.

Die Multi-Faktor-Authentifizierung erhöht die Sicherheit Ihrer Anwendung. Während Angreifer häufig Passwörter und Konten bei sozialen Netzwerken missbrauchen, ist das Abfangen einer SMS schwieriger.

Hinweis

  1. Aktivieren Sie mindestens einen Anbieter, der die Multi-Faktor-Authentifizierung unterstützt. Alle Anbieter unterstützen die MFA, außer die Telefonauthentifizierung, die anonyme Authentifizierung und das Apple Game Center.

  2. Achten Sie darauf, dass die Anwendung die E-Mail-Adressen der Nutzer überprüft. Die Multi-Faktor-Authentifizierung erfordert eine E-Mail-Bestätigung. So wird verhindert, dass sich böswillige Akteure bei einem Dienst mit einer E-Mail-Adresse registrieren, die ihnen nicht gehört, und dann den echten Inhaber sperren, indem sie einen zweiten Faktor hinzufügen.

  3. Registrieren Sie den SHA-1-Hash Ihrer App in der Firebase Console. Ihre Änderungen werden automatisch auf die Google Cloud Identity Platform übertragen.

    1. Führen Sie die Schritte unter Client authentifizieren aus, um den SHA-1-Hash der Anwendung zu erhalten.

    2. Öffnen Sie die Firebase Console.

    3. Gehen Sie zu Projekteinstellungen.

    4. Klicken Sie unter Meine Apps auf das Android-Symbol.

    5. Folgen Sie der Anleitung, um den SHA-1-Hash hinzuzufügen.

Multi-Faktor-Authentifizierung aktivieren

  1. Rufen Sie in der Google Cloud Console die Seite Identity Platform MFA auf.
    MFA aufrufen

  2. Klicken Sie unter Multi-Faktor-Authentifizierung auf Aktivieren.

  3. Geben Sie die Telefonnummern ein, mit denen Sie Ihre Anwendung testen möchten. Die Registrierung von Testnummern ist war optional, wird aber dringend empfohlen, um eine Drosselung während der Entwicklung zu vermeiden.

  4. Falls Sie die Domain Ihrer Anwendung noch nicht autorisiert haben, fügen Sie sie der Zulassungsliste hinzu, indem Sie auf Domain hinzufügen klicken.

  5. Klicken Sie auf Speichern.

Registrierungsmuster auswählen

Sie können auswählen, ob Ihre Anwendung eine Multi-Faktor-Authentifizierung erfordert, und wie und wann Ihre Nutzer registriert werden sollen. Hier einige gängige Muster:

  • Bieten Sie den zweiten Faktor des Nutzers als Teil der Registrierung an. Verwenden Sie diese Methode, wenn Ihre Anwendung eine Multi-Faktor-Authentifizierung für alle Nutzer erfordert.

  • Bieten Sie bei der Registrierung eine überspringbare Option an, mit der ein zweiter Faktor registriert werden kann. Bei Apps, die zwar zur Multi-Faktor-Authentifizierung ermutigen möchten, diese aber nicht erfordern, ist dieser Ansatz möglicherweise die beste Wahl.

  • Ermöglichen Sie, dass ein zweiter Faktor über die Konto- oder Profilverwaltungsseite des Nutzers hinzufügbar ist anstelle über den Anmeldebildschirm. Dadurch wird der Registrierungsprozess vereinfacht und gleichzeitig die Multi-Faktor-Authentifizierung für sicherheitsorientierte Nutzer verfügbar gemacht.

  • Das Hinzufügen eines zweiten Faktors ist erforderlich, wenn der Nutzer auf Features mit höheren Sicherheitsanforderungen zugreifen möchte.

Zweiten Faktor registrieren

So registrieren Sie einen neuen zweiten Faktor für einen Nutzer:

  1. Authentifizieren Sie den Nutzer noch einmal.

  2. Fordern Sie den Nutzer zur Eingabe seiner Telefonnummer auf.

  3. Starten Sie eine Multi-Faktor-Sitzung für den Nutzer:

    Kotlin+KTX 

    user.multiFactor.session.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        val multiFactorSession: MultiFactorSession? = task.result
    }
}

    Java 

    user.getMultiFactor().getSession()
  .addOnCompleteListener(
      new OnCompleteListener<MultiFactorSession>() {
      @Override
      public void onComplete(@NonNull Task<MultiFactorSession> task) {
        if (task.isSuccessful()) {
          MultiFactorSession multiFactorSession = task.getResult();
        }
      }
      });

  4. Erstellen Sie ein OnVerificationStateChangedCallbacks-Objekt, um verschiedene Ereignisse im Bestätigungsprozess zu verarbeiten:

    Kotlin+KTX 

    val callbacks = object : OnVerificationStateChangedCallbacks() {
    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
        // This callback will be invoked in two situations:
        // 1) Instant verification. In some cases, the phone number can be
        //    instantly verified without needing to send or enter a verification
        //    code. You can disable this feature by calling
        //    PhoneAuthOptions.builder#requireSmsValidation(true) when building
        //    the options to pass to PhoneAuthProvider#verifyPhoneNumber().
        // 2) Auto-retrieval. On some devices, Google Play services can
        //    automatically detect the incoming verification SMS and perform
        //    verification without user action.
        this@MainActivity.credential = credential
    }

    override fun onVerificationFailed(e: FirebaseException) {
        // This callback is invoked in response to invalid requests for
        // verification, like an incorrect phone number.
        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
            // ...
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
            // ...
        }
        // Show a message and update the UI
        // ...
    }

    override fun onCodeSent(
        verificationId: String, forceResendingToken: ForceResendingToken
    ) {
        // The SMS verification code has been sent to the provided phone number.
        // We now need to ask the user to enter the code and then construct a
        // credential by combining the code with a verification ID.
        // Save the verification ID and resending token for later use.
        this@MainActivity.verificationId = verificationId
        this@MainActivity.forceResendingToken = forceResendingToken
        // ...
    }
}

    Java 

    OnVerificationStateChangedCallbacks callbacks =
new OnVerificationStateChangedCallbacks() {
  @Override
  public void onVerificationCompleted(PhoneAuthCredential credential) {
    // This callback will be invoked in two situations:
    // 1) Instant verification. In some cases, the phone number can be
    //    instantly verified without needing to send or enter a verification
    //    code. You can disable this feature by calling
    //    PhoneAuthOptions.builder#requireSmsValidation(true) when building
    //    the options to pass to PhoneAuthProvider#verifyPhoneNumber().
    // 2) Auto-retrieval. On some devices, Google Play services can
    //    automatically detect the incoming verification SMS and perform
    //    verification without user action.
    this.credential = credential;
  }
  @Override
  public void onVerificationFailed(FirebaseException e) {
    // This callback is invoked in response to invalid requests for
    // verification, like an incorrect phone number.
    if (e instanceof FirebaseAuthInvalidCredentialsException) {
    // Invalid request
    // ...
    } else if (e instanceof FirebaseTooManyRequestsException) {
    // The SMS quota for the project has been exceeded
    // ...
    }
    // Show a message and update the UI
    // ...
  }
  @Override
  public void onCodeSent(
    String verificationId, PhoneAuthProvider.ForceResendingToken token) {
    // The SMS verification code has been sent to the provided phone number.
    // We now need to ask the user to enter the code and then construct a
    // credential by combining the code with a verification ID.
    // Save the verification ID and resending token for later use.
    this.verificationId = verificationId;
    this.forceResendingToken = token;
    // ...
  }
};

  5. Initialisieren Sie ein PhoneInfoOptions-Objekt mit der Telefonnummer des Nutzers, der Multi-Faktor-Sitzung und Ihren Callbacks:

    Kotlin+KTX 

    val phoneAuthOptions = PhoneAuthOptions.newBuilder()
    .setPhoneNumber(phoneNumber)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setMultiFactorSession(MultiFactorSession)
    .setCallbacks(callbacks)
    .build()

    Java 

    PhoneAuthOptions phoneAuthOptions =
  PhoneAuthOptions.newBuilder()
      .setPhoneNumber(phoneNumber)
      .setTimeout(30L, TimeUnit.SECONDS)
      .setMultiFactorSession(multiFactorSession)
      .setCallbacks(callbacks)
      .build();

    Die sofortige Bestätigung ist standardmäßig aktiviert. Wenn Sie es deaktivieren möchten, fügen Sie requireSmsValidation(true) hinzu.

  6. Senden Sie eine Bestätigungsnachricht an das Mobiltelefon des Nutzers:

    Kotlin+KTX 

    PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions)

    Java 

    PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions);

    Als Best Practice wird empfohlen, die Nutzer vorab darüber zu informieren, dass sie eine SMS erhalten und dabei die üblichen Gebühren anfallen.

  7. Nachdem der SMS-Code gesendet wurde, bitten Sie den Nutzer, den Code zu bestätigen:

    Kotlin+KTX 

    // Ask user for the verification code.
val credential = PhoneAuthProvider.getCredential(verificationId, verificationCode)

    Java 

    // Ask user for the verification code.
PhoneAuthCredential credential
  = PhoneAuthProvider.getCredential(verificationId, verificationCode);

  8. Initialisieren Sie ein MultiFactorAssertion-Objekt mit PhoneAuthCredential:

    Kotlin+KTX 

    val multiFactorAssertion
  = PhoneMultiFactorGenerator.getAssertion(credential)

    Java 

    MultiFactorAssertion multiFactorAssertion
  = PhoneMultiFactorGenerator.getAssertion(credential);

  9. Schließen Sie die Anmeldung ab. Optional können Sie einen Anzeigenamen für den zweiten Faktor angeben. Dies ist für Nutzer mit mehreren zweiten Faktoren hilfreich, da die Telefonnummer während des Authentifizierungsvorgangs maskiert wird (z. B. +1******1234).

    Kotlin+KTX 

    // Complete enrollment. This will update the underlying tokens
// and trigger ID token change listener.
FirebaseAuth.getInstance()
    .currentUser
    ?.multiFactor
    ?.enroll(multiFactorAssertion, "My personal phone number")
    ?.addOnCompleteListener {
        // ...
    }

    Java 

    // Complete enrollment. This will update the underlying tokens
// and trigger ID token change listener.
FirebaseAuth.getInstance()
  .getCurrentUser()
  .getMultiFactor()
  .enroll(multiFactorAssertion, "My personal phone number")
  .addOnCompleteListener(
      new OnCompleteListener<Void>() {
      @Override
      public void onComplete(@NonNull Task<Void> task) {
        // ...
      }
      });

Der folgende Code zeigt ein vollständiges Beispiel für die Registrierung eines zweiten Faktors:

Kotlin+KTX 

val multiFactorAssertion = PhoneMultiFactorGenerator.getAssertion(credential)
user.multiFactor.session
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            val multiFactorSession = task.result
            val phoneAuthOptions = PhoneAuthOptions.newBuilder()
                .setPhoneNumber(phoneNumber)
                .setTimeout(30L, TimeUnit.SECONDS)
                .setMultiFactorSession(multiFactorSession)
                .setCallbacks(callbacks)
                .build()
            // Send SMS verification code.
            PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions)
        }
    }

// Ask user for the verification code.
val credential = PhoneAuthProvider.getCredential(verificationId, verificationCode)

val multiFactorAssertion = PhoneMultiFactorGenerator.getAssertion(credential)

// Complete enrollment.
FirebaseAuth.getInstance()
    .currentUser
    ?.multiFactor
    ?.enroll(multiFactorAssertion, "My personal phone number")
    ?.addOnCompleteListener {
        // ...
    }

Java 

MultiFactorAssertion multiFactorAssertion = PhoneMultiFactorGenerator.getAssertion(credential);
user.getMultiFactor().getSession()
  .addOnCompleteListener(
      new OnCompleteListener<MultiFactorSession>() {
      @Override
      public void onComplete(@NonNull Task<MultiFactorSession> task) {
        if (task.isSuccessful()) {
          MultiFactorSession multiFactorSession = task.getResult();
          PhoneAuthOptions phoneAuthOptions =
            PhoneAuthOptions.newBuilder()
                .setPhoneNumber(phoneNumber)
                .setTimeout(30L, TimeUnit.SECONDS)
                .setMultiFactorSession(multiFactorSession)
                .setCallbacks(callbacks)
                .build();
          // Send SMS verification code.
          PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions);
        }
      }
      });

// Ask user for the verification code.
PhoneAuthCredential credential =
  PhoneAuthProvider.getCredential(verificationId, verificationCode);

MultiFactorAssertion multiFactorAssertion = PhoneMultiFactorGenerator.getAssertion(credential);
// Complete enrollment.
FirebaseAuth.getInstance()
  .getCurrentUser()
  .getMultiFactor()
  .enroll(multiFactorAssertion, "My personal phone number")
  .addOnCompleteListener(
      new OnCompleteListener<Void>() {
      @Override
      public void onComplete(@NonNull Task<Void> task) {
        // ...
      }
      });

Glückwunsch! Sie haben erfolgreich einen zweiten Authentifizierungsfaktor für einen Nutzer registriert.

Nutzer mit einem zweiten Faktor anmelden

So melden Sie einen Nutzer mit der SMS-Bestätigung in zwei Schritten an:

  1. Melden Sie den Nutzer mit dessen ersten Faktor an. Dann rufen Sie die Ausnahme FirebaseAuthMultiFactorException ab. Dieser Fehler enthält einen Resolver, mit dem Sie die registrierten Zweiten faktoren des Nutzers abrufen können. Er enthält auch eine zugrunde liegende Sitzung, die bestätigt, dass der Nutzer mit seinem ersten Faktor authentifiziert wurde.

    Wenn der erste Faktor des Nutzers beispielsweise eine E-Mail und ein Passwort war, tun Sie Folgendes:

    Kotlin+KTX 

    FirebaseAuth.getInstance()
    .signInWithEmailAndPassword(email, password)
    .addOnCompleteListener(
        OnCompleteListener { task ->
            if (task.isSuccessful) {
                // User is not enrolled with a second factor and is successfully
                // signed in.
                // ...
                return@OnCompleteListener
            }
            if (task.exception is FirebaseAuthMultiFactorException) {
                // The user is a multi-factor user. Second factor challenge is
                // required.
                val multiFactorResolver =
                    (task.exception as FirebaseAuthMultiFactorException).resolver
                // ...
            } else {
                // Handle other errors, such as wrong password.
            }
        })

    Java 

    FirebaseAuth.getInstance()
  .signInWithEmailAndPassword(email, password)
  .addOnCompleteListener(
      new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // User is not enrolled with a second factor and is successfully
          // signed in.
          // ...
          return;
        }
        if (task.getException() instanceof FirebaseAuthMultiFactorException) {
          // The user is a multi-factor user. Second factor challenge is
          // required.
          MultiFactorResolver multiFactorResolver = task.getException().getResolver();
          // ...
        } else {
          // Handle other errors such as wrong password.
        }
      }
      });

    Wenn der erste Faktor des Nutzers ein föderierter Anbieter wie OAuth ist, rufen Sie nach dem Aufruf von startActivityForSignInWithProvider() den Fehler ab.

  2. Wenn der Nutzer mehrere sekundäre Faktoren registriert hat, fragen Sie ihn, welchen er verwenden möchte:

    Kotlin+KTX 

    // Ask user which second factor to use.
// You can get the list of enrolled second factors using
//   multiFactorResolver.hints

// Check the selected factor:
if (multiFactorResolver.hints[selectedIndex].factorId
    === PhoneMultiFactorGenerator.FACTOR_ID
) {
    // User selected a phone second factor.
    val selectedHint =
        multiFactorResolver.hints[selectedIndex] as PhoneMultiFactorInfo
} else if (multiFactorResolver.hints[selectedIndex].factorId
    === TotpMultiFactorGenerator.FACTOR_ID) {
    // User selected a TOTP second factor.
} else {
    // Unsupported second factor.
}

    Java 

    // Ask user which second factor to use.
// You can get the masked phone number using
// resolver.getHints().get(selectedIndex).getPhoneNumber()
// You can get the display name using
// resolver.getHints().get(selectedIndex).getDisplayName()
if ( resolver.getHints()
               .get(selectedIndex)
               .getFactorId()
               .equals( PhoneMultiFactorGenerator.FACTOR_ID ) ) {
// User selected a phone second factor.
MultiFactorInfo selectedHint =
  multiFactorResolver.getHints().get(selectedIndex);
} else if ( resolver
              .getHints()
              .get(selectedIndex)
              .getFactorId()
              .equals(TotpMultiFactorGenerator.FACTOR_ID ) ) {
  // User selected a TOTP second factor.
} else {
// Unsupported second factor.
}

  3. Initialisieren Sie ein PhoneAuthOptions-Objekt mit dem Hinweis und der Multi-Faktor-Sitzung. Diese Werte sind in dem Resolver enthalten, der an FirebaseAuthMultiFactorException angehängt ist.

    Kotlin+KTX 

    val phoneAuthOptions = PhoneAuthOptions.newBuilder()
    .setMultiFactorHint(selectedHint)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setMultiFactorSession(multiFactorResolver.session)
    .setCallbacks(callbacks) // Optionally disable instant verification.
    // .requireSmsValidation(true)
    .build()

    Java 

    PhoneAuthOptions phoneAuthOptions =
  PhoneAuthOptions.newBuilder()
      .setMultiFactorHint(selectedHint)
      .setTimeout(30L, TimeUnit.SECONDS)
      .setMultiFactorSession(multiFactorResolver.getSession())
      .setCallbacks(callbacks)
      // Optionally disable instant verification.
      // .requireSmsValidation(true)
      .build();

  4. Senden Sie eine Bestätigungsnachricht an das Mobiltelefon des Nutzers:

    Kotlin+KTX 

    // Send SMS verification code
PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions)

    Java 

    // Send SMS verification code
PhoneAuthProvider.verifyPhoneNumber(phoneAuthOptions);

  5. Nachdem der SMS-Code gesendet wurde, bitten Sie den Nutzer, den Code zu bestätigen:

    Kotlin+KTX 

    // Ask user for the verification code. Then, pass it to getCredential:
val credential =
    PhoneAuthProvider.getCredential(verificationId, verificationCode)

    Java 

    // Ask user for the verification code. Then, pass it to getCredential:
PhoneAuthCredential credential
    = PhoneAuthProvider.getCredential(verificationId, verificationCode);

  6. Initialisieren Sie ein MultiFactorAssertion-Objekt mit PhoneAuthCredential:

    Kotlin+KTX 

    val multiFactorAssertion = PhoneMultiFactorGenerator.getAssertion(credential)

    Java 

    MultiFactorAssertion multiFactorAssertion
    = PhoneMultiFactorGenerator.getAssertion(credential);

  7. Rufen Sie resolver.resolveSignIn() auf, um die sekundäre Authentifizierung abzuschließen. Sie können dann auf das ursprüngliche Anmeldeergebnis zugreifen, das die anbieterspezifischen Daten und Anmeldedaten zur Authentifizierung enthält:

    Kotlin+KTX 

    multiFactorResolver
    .resolveSignIn(multiFactorAssertion)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            val authResult = task.result
            // AuthResult will also contain the user, additionalUserInfo,
            // and an optional credential (null for email/password)
            // associated with the first factor sign-in.

            // For example, if the user signed in with Google as a first
            // factor, authResult.getAdditionalUserInfo() will contain data
            // related to Google provider that the user signed in with;
            // authResult.getCredential() will contain the Google OAuth
            //   credential;
            // authResult.getCredential().getAccessToken() will contain the
            //   Google OAuth access token;
            // authResult.getCredential().getIdToken() contains the Google
            //   OAuth ID token.
        }
    }

    Java 

    multiFactorResolver
  .resolveSignIn(multiFactorAssertion)
  .addOnCompleteListener(
      new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          AuthResult authResult = task.getResult();
          // AuthResult will also contain the user, additionalUserInfo,
          // and an optional credential (null for email/password)
          // associated with the first factor sign-in.
          // For example, if the user signed in with Google as a first
          // factor, authResult.getAdditionalUserInfo() will contain data
          // related to Google provider that the user signed in with.
          // authResult.getCredential() will contain the Google OAuth
          // credential.
          // authResult.getCredential().getAccessToken() will contain the
          // Google OAuth access token.
          // authResult.getCredential().getIdToken() contains the Google
          // OAuth ID token.
        }
      }
      });

Der folgende Code zeigt ein vollständiges Beispiel für die Anmeldung eines Multi-Faktor-Nutzers:

Kotlin+KTX 

FirebaseAuth.getInstance()
    .signInWithEmailAndPassword(email, password)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            // User is not enrolled with a second factor and is successfully
            // signed in.
            // ...
            return@addOnCompleteListener
        }
        if (task.exception is FirebaseAuthMultiFactorException) {
            val multiFactorResolver =
                (task.exception as FirebaseAuthMultiFactorException).resolver

            // Ask user which second factor to use. Then, get
            // the selected hint:
            val selectedHint =
                multiFactorResolver.hints[selectedIndex] as PhoneMultiFactorInfo

            // Send the SMS verification code.
            PhoneAuthProvider.verifyPhoneNumber(
                PhoneAuthOptions.newBuilder()
                    .setActivity(this)
                    .setMultiFactorSession(multiFactorResolver.session)
                    .setMultiFactorHint(selectedHint)
                    .setCallbacks(generateCallbacks())
                    .setTimeout(30L, TimeUnit.SECONDS)
                    .build()
            )

            // Ask user for the SMS verification code, then use it to get
            // a PhoneAuthCredential:
            val credential =
                PhoneAuthProvider.getCredential(verificationId, verificationCode)

            // Initialize a MultiFactorAssertion object with the
            // PhoneAuthCredential.
            val multiFactorAssertion: MultiFactorAssertion =
                PhoneMultiFactorGenerator.getAssertion(credential)

            // Complete sign-in.
            multiFactorResolver
                .resolveSignIn(multiFactorAssertion)
                .addOnCompleteListener { task ->
                    if (task.isSuccessful) {
                        // User successfully signed in with the
                        // second factor phone number.
                    }
                    // ...
                }
        } else {
            // Handle other errors such as wrong password.
        }
    }

Java 

FirebaseAuth.getInstance()
  .signInWithEmailAndPassword(email, password)
  .addOnCompleteListener(
      new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // User is not enrolled with a second factor and is successfully
          // signed in.
          // ...
          return;
        }
        if (task.getException() instanceof FirebaseAuthMultiFactorException) {
          FirebaseAuthMultiFactorException e =
            (FirebaseAuthMultiFactorException) task.getException();

          MultiFactorResolver multiFactorResolver = e.getResolver();

          // Ask user which second factor to use.
          MultiFactorInfo selectedHint =
            multiFactorResolver.getHints().get(selectedIndex);

          // Send the SMS verification code.
          PhoneAuthProvider.verifyPhoneNumber(
            PhoneAuthOptions.newBuilder()
                .setActivity(this)
                .setMultiFactorSession(multiFactorResolver.getSession())
                .setMultiFactorHint(selectedHint)
                .setCallbacks(generateCallbacks())
                .setTimeout(30L, TimeUnit.SECONDS)
                .build());

          // Ask user for the SMS verification code.
          PhoneAuthCredential credential =
            PhoneAuthProvider.getCredential(verificationId, verificationCode);

          // Initialize a MultiFactorAssertion object with the
          // PhoneAuthCredential.
          MultiFactorAssertion multiFactorAssertion =
            PhoneMultiFactorGenerator.getAssertion(credential);

          // Complete sign-in.
          multiFactorResolver
            .resolveSignIn(multiFactorAssertion)
            .addOnCompleteListener(
                new OnCompleteListener<AuthResult>() {
                  @Override
                  public void onComplete(@NonNull Task<AuthResult> task) {
                  if (task.isSuccessful()) {
                    // User successfully signed in with the
                    // second factor phone number.
                  }
                  // ...
                  }
                });
        } else {
          // Handle other errors such as wrong password.
        }
      }
      });

Glückwunsch! Sie haben sich erfolgreich mit einer Multi-Faktor-Authentifizierung für einen Nutzer angemeldet.

Nächste Schritte