Diese Seite wurde von der Cloud Translation API übersetzt.

Nutzer über eine Chrome-Erweiterung anmelden

In diesem Dokument erfahren Sie, wie Sie Nutzer mit Identity Platform in einer Chrome-Erweiterung anmelden, die Manifest V3 verwendet.

Identity Platform bietet mehrere Authentifizierungsmethoden, um Nutzer über eine Chrome-Erweiterung anzumelden. Einige erfordern mehr Entwicklungsaufwand als andere.

Wenn Sie die folgenden Methoden in einer Chrome-Erweiterung mit Manifest V3 verwenden möchten, müssen Sie sie nur aus firebase/auth/web-extension importieren:

Mit E-Mail-Adresse und Passwort anmelden (createUserWithEmailAndPassword und signInWithEmailAndPassword)
Über E-Mail-Link anmelden (sendSignInLinkToEmail, isSignInWithEmailLink und signInWithEmailLink)
Anonym anmelden (signInAnonymously)
Über ein benutzerdefiniertes Authentifizierungssystem anmelden (signInWithCustomToken)
Anbieteranmeldung unabhängig verarbeiten und dann signInWithCredential verwenden

Die folgenden Anmeldemethoden werden ebenfalls unterstützt, erfordern aber etwas zusätzliche Arbeit:

Über ein Pop-up-Fenster anmelden (signInWithPopup, linkWithPopup und reauthenticateWithPopup)
Über die Anmeldeseite anmelden (signInWithRedirect, linkWithRedirect und reauthenticateWithRedirect)
Mit reCAPTCHA per Telefonnummer anmelden
SMS-Multi-Faktor-Authentifizierung mit reCAPTCHA
reCAPTCHA Enterprise-Schutz

Wenn Sie diese Methoden in einer Chrome-Erweiterung mit Manifest V3 verwenden möchten, müssen Sie Offscreen-Dokumente verwenden.

Den Einstiegspunkt „firebase/auth/web-extension“ verwenden

Wenn Sie aus firebase/auth/web-extension importieren, funktioniert die Anmeldung von Nutzern über eine Chrome-Erweiterung ähnlich wie bei einer Webanwendung.

firebase/auth/web-extension wird nur von Web SDK-Versionen ab 10.8.0 unterstützt.

import { getAuth, signInWithEmailAndPassword } from 'firebase/auth/web-extension';

const auth = getAuth();
signInWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
    // Signed in
    const user = userCredential.user;
    // ...
  })
  .catch((error) => {
    const errorCode = error.code;
    const errorMessage = error.message;
  });

Nicht sichtbare Dokumente verwenden

Einige Authentifizierungsmethoden wie signInWithPopup, linkWithPopup und reauthenticateWithPopup sind nicht direkt mit Chrome-Erweiterungen kompatibel, da für sie Code von außerhalb des Erweiterungspakets geladen werden muss. Ab Manifest V3 ist dies nicht mehr zulässig und wird von der Erweiterungsplattform blockiert. Sie können diesen Code jedoch über ein Offscreen-Dokument in einem Iframe laden. Implementieren Sie im Offscreen-Dokument den normalen Authentifizierungsablauf und leiten Sie das Ergebnis aus dem Offscreen-Dokument per Proxy zurück an die Erweiterung.

In dieser Anleitung wird signInWithPopup als Beispiel verwendet. Das gleiche Konzept gilt jedoch auch für andere Authentifizierungsmethoden.

Hinweise

Dazu müssen Sie eine Webseite einrichten, die im Web verfügbar ist und die Sie in einem Iframe laden. Dazu eignet sich jeder Host, einschließlich Firebase Hosting. Erstellen Sie eine Website mit folgendem Inhalt:

<!DOCTYPE html>
<html>
  <head>
    <title>signInWithPopup</title>
    <script src="signInWithPopup.js"></script>
  </head>
  <body><h1>signInWithPopup</h1></body>
</html>

Wenn Sie die föderierte Anmeldung verwenden, z. B. die Anmeldung über Google, Apple, SAML oder OIDC, müssen Sie die ID Ihrer Chrome-Erweiterung der Liste der autorisierten Domains hinzufügen:

Rufen Sie in der Google Cloud Console die Seite Identity Platform-Einstellungen auf.

Zur Seite "Einstellungen"
Wählen Sie den Tab Sicherheit aus.
Klicken Sie unter Autorisierte Domains auf Domain hinzufügen.
Geben Sie den URI der Erweiterung ein. Er sollte etwa folgendermaßen aussehen: chrome-extension://CHROME_EXTENSION_ID
Klicken Sie auf Hinzufügen.

Fügen Sie in der Manifestdatei Ihrer Chrome-Erweiterung die folgenden URLs zur Zulassungsliste content_security_policy hinzu:

https://apis.google.com
https://www.gstatic.com
https://www.googleapis.com
https://securetoken.googleapis.com

Authentifizierung implementieren

In Ihrem HTML-Dokument ist „signInWithPopup.js“ der JavaScript-Code, der die Authentifizierung verarbeitet. Es gibt zwei Möglichkeiten, eine Methode zu implementieren, die direkt in der Erweiterung unterstützt wird:

Verwenden Sie firebase/auth anstelle von firebase/auth/web-extension. Der Einstiegspunkt web-extension ist für Code gedacht, der in der Erweiterung ausgeführt wird. Dieser Code wird zwar in der Erweiterung ausgeführt (in einem Iframe, in Ihrem Offscreen-Dokument), aber im Standard-Web.
Hülle die Authentifizierungslogik in einen postMessage-Listener ein, um die Authentifizierungsanfrage und ‑antwort zu proxyen.

import { signInWithPopup, GoogleAuthProvider, getAuth } from'firebase/auth';
import { initializeApp } from 'firebase/app';
import firebaseConfig from './firebaseConfig.js'

const app = initializeApp(firebaseConfig);
const auth = getAuth();

// This code runs inside of an iframe in the extension's offscreen document.
// This gives you a reference to the parent frame, i.e. the offscreen document.
// You will need this to assign the targetOrigin for postMessage.
const PARENT_FRAME = document.location.ancestorOrigins[0];

// This demo uses the Google auth provider, but any supported provider works.
// Make sure that you enable any provider you want to use in the Firebase Console.
// https://console.firebase.google.com/project/_/authentication/providers
const PROVIDER = new GoogleAuthProvider();

function sendResponse(result) {
  globalThis.parent.self.postMessage(JSON.stringify(result), PARENT_FRAME);
}

globalThis.addEventListener('message', function({data}) {
  if (data.initAuth) {
    // Opens the Google sign-in page in a popup, inside of an iframe in the
    // extension's offscreen document.
    // To centralize logic, all respones are forwarded to the parent frame,
    // which goes on to forward them to the extension's service worker.
    signInWithPopup(auth, PROVIDER)
      .then(sendResponse)
      .catch(sendResponse)
  }
});

Chrome-Erweiterung erstellen

Sobald Ihre Website online ist, können Sie sie in Ihrer Chrome-Erweiterung verwenden.

Fügen Sie der Datei „manifest.json“ die Berechtigung „offscreen“ hinzu:

    {
      "name": "signInWithPopup Demo",
      "manifest_version" 3,
      "background": {
        "service_worker": "background.js"
      },
      "permissions": [
        "offscreen"
      ]
    }

Erstellen Sie das Offscreen-Dokument selbst. Dies ist eine minimale HTML-Datei in Ihrem Erweiterungspaket, die die Logik Ihres Offscreen-Dokument-JavaScript lädt:

    <!DOCTYPE html>
    <script src="./offscreen.js"></script>

Fügen Sie offscreen.js in Ihr Erweiterungspaket ein. Er fungiert als Proxy zwischen der in Schritt 1 eingerichteten öffentlichen Website und Ihrer Erweiterung.

    // This URL must point to the public site
    const _URL = 'https://example.com/signInWithPopupExample';
    const iframe = document.createElement('iframe');
    iframe.src = _URL;
    document.documentElement.appendChild(iframe);
    chrome.runtime.onMessage.addListener(handleChromeMessages);

    function handleChromeMessages(message, sender, sendResponse) {
      // Extensions may have an number of other reasons to send messages, so you
      // should filter out any that are not meant for the offscreen document.
      if (message.target !== 'offscreen') {
        return false;
      }

      function handleIframeMessage({data}) {
        try {
          if (data.startsWith('!_{')) {
            // Other parts of the Firebase library send messages using postMessage.
            // You don't care about them in this context, so return early.
            return;
          }
          data = JSON.parse(data);
          self.removeEventListener('message', handleIframeMessage);

          sendResponse(data);
        } catch (e) {
          console.log(`json parse failed - ${e.message}`);
        }
      }

      globalThis.addEventListener('message', handleIframeMessage, false);

      // Initialize the authentication flow in the iframed document. You must set the
      // second argument (targetOrigin) of the message in order for it to be successfully
      // delivered.
      iframe.contentWindow.postMessage({"initAuth": true}, new URL(_URL).origin);
      return true;
    }

Richten Sie das Offscreen-Dokument über Ihren background.js-Dienstworker ein.

    const OFFSCREEN_DOCUMENT_PATH = '/offscreen.html';

    // A global promise to avoid concurrency issues
    let creatingOffscreenDocument;

    // Chrome only allows for a single offscreenDocument. This is a helper function
    // that returns a boolean indicating if a document is already active.
    async function hasDocument() {
      // Check all windows controlled by the service worker to see if one
      // of them is the offscreen document with the given path
      const matchedClients = await clients.matchAll();
      return matchedClients.some(
        (c) => c.url === chrome.runtime.getURL(OFFSCREEN_DOCUMENT_PATH)
      );
    }

    async function setupOffscreenDocument(path) {
      // If we do not have a document, we are already setup and can skip
      if (!(await hasDocument())) {
        // create offscreen document
        if (creating) {
          await creating;
        } else {
          creating = chrome.offscreen.createDocument({
            url: path,
            reasons: [
                chrome.offscreen.Reason.DOM_SCRAPING
            ],
            justification: 'authentication'
          });
          await creating;
          creating = null;
        }
      }
    }

    async function closeOffscreenDocument() {
      if (!(await hasDocument())) {
        return;
      }
      await chrome.offscreen.closeDocument();
    }

    function getAuth() {
      return new Promise(async (resolve, reject) => {
        const auth = await chrome.runtime.sendMessage({
          type: 'firebase-auth',
          target: 'offscreen'
        });
        auth?.name !== 'FirebaseError' ? resolve(auth) : reject(auth);
      })
    }

    async function firebaseAuth() {
      await setupOffscreenDocument(OFFSCREEN_DOCUMENT_PATH);

      const auth = await getAuth()
        .then((auth) => {
          console.log('User Authenticated', auth);
          return auth;
        })
        .catch(err => {
          if (err.code === 'auth/operation-not-allowed') {
            console.error('You must enable an OAuth provider in the Firebase' +
                          ' console in order to use signInWithPopup. This sample' +
                          ' uses Google by default.');
          } else {
            console.error(err);
            return err;
          }
        })
        .finally(closeOffscreenDocument)

      return auth;
    }

Wenn Sie firebaseAuth() jetzt in Ihrem Service Worker aufrufen, wird das Offscreen-Dokument erstellt und die Website in einem iFrame geladen. Dieser Iframe wird im Hintergrund verarbeitet und Firebase führt den standardmäßigen Authentifizierungsablauf durch. Sobald es entweder aufgelöst oder abgelehnt wurde, wird das Authentifizierungsobjekt über das Offscreen-Dokument von Ihrem Iframe an Ihren Service Worker weitergeleitet.