Authentifizierung mit Firebase unter Android über die Firebase-Telefonnummernüberprüfung

In der öffentlichen Vorschau von Firebase PNV kann Firebase Authentication kein Firebase PNV-Token für die Anmeldung direkt akzeptieren. Sie können Nutzern jedoch die Anmeldung mit Firebase PNV ermöglichen, indem Sie die benutzerdefinierte Authentifizierungsfunktion von Firebase Authentication verwenden.

Token-Austausch-Endpunkt erstellen

Der wichtigste Schritt bei der Implementierung einer benutzerdefinierten Authentifizierungslösung in Firebase ist das Erstellen eines Endpunkts, der ein Firebase PNV-Token empfangen, validieren und dann ein benutzerdefiniertes Firebase-Authentifizierungstoken ausstellen kann. Ihre Anwendung kann dieses benutzerdefinierte Token dann verwenden, um den Nutzer anzumelden.

Dieser Endpunkt kann auf jeder Plattform gehostet werden. Im folgenden Beispiel wird der Endpunkt jedoch mit Cloud Functions for Firebase gehostet:

Node.js

import { JwtVerifier } from "aws-jwt-verify";
import { getApp } from "firebase-admin/app";
import { getAuth, UserRecord } from "firebase-admin/auth";
import { onRequest } from "firebase-functions/https";

// Because we're deploying to Cloud Functions for Firebase, admin credentials
// are automatically available.
const app = getApp();
const authAdmin = getAuth(app);

// Find your Firebase project number in the Firebase console.
const FIREBASE_PROJECT_NUMBER = "123456789";

// The issuer and audience claims of the FPNV token are specific to your
// project.
const issuer = `https://fpnv.googleapis.com/projects/${FIREBASE_PROJECT_NUMBER}`;
const audience = `https://fpnv.googleapis.com/projects/${FIREBASE_PROJECT_NUMBER}`;

// The JWKS URL contains the current public signing keys for FPNV tokens.
const jwksUri = "https://fpnv.googleapis.com/v1beta/jwks";

// Configure a JWT verifier to check the following:
// - The token is signed by Google
// - The issuer and audience claims match your project
// - The token has not yet expired (default begavior)
const fpnvVerifier = JwtVerifier.create({ issuer, audience, jwksUri });

// This Cloud Function is your token exchange endpoint. You pass the endpoint an
// FPNV token, and the Cloud Function verifies it and exchanges it for a
// Firebase Auth token corresponding to the same user.
export const signInWithFpnv = onRequest(async (req, res) => {
    // Get the FPNV token from the request body.
    const fpnvToken = req.body?;
    if (!fpnvToken) {
        res.sendStatus(400);
        return;
    }

    let verifiedPhoneNumber;
    try {
        // Attempt to verify the token using the verifier configured above.
        const verifiedPayload = await fpnvVerifier.verify(fpnvToken);

        // If verification succeeds, the subject claim of the token contains the
        // verified phone number.
        verifiedPhoneNumber = verifiedPayload.sub;
    } catch {
        // If verification fails, reject the token.
        res.sendStatus(403);
        return;
    }

    // Now that you have a verified phone number, look it up in your Firebase
    // project's user database.
    let user: UserRecord;
    try {
        // If a user account already exists with the phone number, retrieve it.
        user = await authAdmin.getUserByPhoneNumber(verifiedPhoneNumber);
    } catch {
        // Otherwise, create a new user account using the phone number.
        user = await authAdmin.createUser({phoneNumber: verifiedPhoneNumber});
    }

    // Finally, mint a Firebase custom auth token containing the UID of the user
    // you looked up or created. Return this token to the caller.
    const authToken = await authAdmin.createCustomToken(user.uid);
    res.status(200).send(authToken);
    return;
});

Mit dem benutzerdefinierten Auth-Token anmelden

Nachdem der Endpunkt bereitgestellt wurde, melden Sie Nutzer in Firebase an. Gehen Sie dazu so vor:

  1. Rufen Sie ein Firebase PNV-Token mit dem auf der Seite Erste Schritte mit Firebase Phone Number Verification beschriebenen Ablauf ab.

  2. Übergeben Sie dieses Token an den Cloud Functions-Endpunkt. Der Endpunkt gibt ein benutzerdefiniertes Authentifizierungstoken an Ihre App zurück, das Sie an signInWithCustomToken() übergeben können.

    Sie könnten beispielsweise mit Retrofit eine Methode, signInWithFpnvToken(), schreiben, die eine ähnliche Schnittstelle wie eine der signin-Methoden von Firebase hat:

    Kotlin 

    class FpnvSigninExample {
    interface FPNVTokenExchangeService {
        @POST("signInWithFpnv")
        suspend fun signInWithFpnv(@Body fpnvToken: String): String
    }

    val retrofit = Retrofit.Builder()
        .baseUrl("https://example-project.cloudfunctions.net/")
        .build()
    val service: FPNVTokenExchangeService = retrofit.create(FPNVTokenExchangeService::class.java)

    suspend fun signInWithFpnvToken(fpnvToken: String): Task<AuthResult?> = coroutineScope {
        val authToken = service.signInWithFpnv(fpnvToken)
        return@coroutineScope Firebase.auth.signInWithCustomToken(authToken)
    }
}