अपने वेब ऐप्लिकेशन में एक से ज़्यादा तरीकों से पुष्टि करने की सुविधा (TOTP) जोड़ें

अगर आपने Firebase Authentication with Identity Platform पर अपग्रेड किया है, तो अपने ऐप्लिकेशन में, समय के हिसाब से मिलने वाला एक बार इस्तेमाल होने वाला पासवर्ड (TOTP) और बहु-स्तरीय पुष्टि (MFA) जोड़ा जा सकता है.

Firebase Authentication with Identity Platform की मदद से, एमएफ़ए के लिए अतिरिक्त फ़ैक्टर के तौर पर टीओटीपी का इस्तेमाल किया जा सकता है. इस सुविधा को चालू करने पर, आपके ऐप्लिकेशन में साइन इन करने वाले उपयोगकर्ताओं को एक बार इस्तेमाल होने वाला पासवर्ड (टीओटीपी) का अनुरोध दिखता है. इसे जनरेट करने के लिए, उपयोगकर्ता को ऐसे ऑथेंटिकेटर ऐप्लिकेशन का इस्तेमाल करना होगा जो मान्य टीओटीपी कोड जनरेट कर सके. जैसे, Google Authenticator.

शुरू करने से पहले

  1. एमएफ़ए (मल्टी-फ़ैक्टर ऑथेंटिकेशन) की सुविधा देने वाली कम से कम एक सेवा चालू करें. ध्यान दें कि यहां बताई गई कंपनियों के अलावा, सभी सेवा देने वाली कंपनियां एमएफ़ए की सुविधा देती हैं:

    • फ़ोन से पुष्टि करना
    • पहचान छिपाकर पुष्टि करना
    • कस्टम पुष्टि करने वाले टोकन
    • Apple Game Center

  2. पक्का करें कि आपका ऐप्लिकेशन, उपयोगकर्ता के ईमेल पतों की पुष्टि करता हो. एमएफ़ए के लिए, ईमेल पते की पुष्टि करना ज़रूरी है. इससे नुकसान पहुंचाने वाले लोग, किसी सेवा के लिए ऐसे ईमेल पते से रजिस्टर नहीं कर पाते जिसका मालिकाना हक उनके पास नहीं है. साथ ही, दूसरा फ़ैक्टर जोड़कर, ईमेल पते के असली मालिक को लॉक आउट नहीं कर पाते.

  3. अगर आपने अब तक ऐसा नहीं किया है, तो Firebase JavaScript SDK इंस्टॉल करें.

    टीओटीपी एमएफ़ए की सुविधा, सिर्फ़ मॉड्यूलर वेब SDK के v9.19.1 और उससे बाद के वर्शन पर काम करती है.

टीओटीपी एमएफ़ए चालू करना

टीओटीपी को दूसरे फ़ैक्टर के तौर पर चालू करने के लिए, Admin SDK का इस्तेमाल करें या प्रोजेक्ट कॉन्फ़िगरेशन के REST एंडपॉइंट को कॉल करें.

Admin SDK का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. अगर आपने अब तक ऐसा नहीं किया है, तो Firebase Admin Node.js SDK टूल इंस्टॉल करें.

    टीओटीपी एमएफ़ए सिर्फ़ Firebase Admin Node.js SDK टूल के 11.6.0 और इसके बाद के वर्शन पर काम करता है.

  2. यह तरीका अपनाएं:

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

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

    इनकी जगह ये डालें:

    • NUM_ADJ_INTERVALS: एक-दूसरे से जुड़ी समय-विंडो के इंटरवल की संख्या, जिसमें टीओटीपी स्वीकार किए जा सकते हैं. यह संख्या शून्य से 10 के बीच हो सकती है. डिफ़ॉल्ट रूप से, यह संख्या पांच होती है.

      टीओटीपी इस तरह काम करते हैं कि जब दो पक्ष (पुष्टि करने वाला और पुष्टि करने वाला) एक ही समयावधि (आम तौर पर 30 सेकंड) में ओटीपी जनरेट करते हैं, तो वे एक ही पासवर्ड जनरेट करते हैं. हालांकि, दोनों पक्षों के बीच टाइम डिफ़रेंस और जवाब देने में लगने वाले समय को ध्यान में रखते हुए, आपके पास टीओटीपी सेवा को कॉन्फ़िगर करने का विकल्प है, ताकि आप आस-पास की विंडो से भी टीओटीपी स्वीकार कर सकें.

REST API का इस्तेमाल करके, टीओटीपी एमएफ़ए को चालू करने के लिए, यह तरीका अपनाएं:

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
            }
          }]
       }
    }'

इनकी जगह ये डालें:

  • PROJECT_ID: प्रोजेक्ट आईडी.

  • NUM_ADJ_INTERVALS: टाइम-विंडो के इंटरवल की संख्या, जो शून्य से 10 के बीच हो सकती है. डिफ़ॉल्ट रूप से, यह पांच पर सेट होता है.

    टीओटीपी इस तरह काम करते हैं कि जब दो पक्ष (पुष्टि करने वाला और पुष्टि करने वाला) एक ही समयावधि (आम तौर पर 30 सेकंड) में ओटीपी जनरेट करते हैं, तो वे एक ही पासवर्ड जनरेट करते हैं. हालांकि, दोनों पक्षों के बीच टाइम डिफ़रेंस और जवाब देने में लगने वाले समय को ध्यान में रखते हुए, आपके पास टीओटीपी सेवा को कॉन्फ़िगर करने का विकल्प है, ताकि आप आस-पास की विंडो से भी टीओटीपी स्वीकार कर सकें.

रजिस्ट्रेशन का पैटर्न चुनना

आपके पास यह चुनने का विकल्प होता है कि आपके ऐप्लिकेशन के लिए, कई तरीकों से पुष्टि करने की ज़रूरत है या नहीं. साथ ही, यह भी चुना जा सकता है कि उपयोगकर्ताओं को कब और कैसे रजिस्टर किया जाए. कुछ सामान्य पैटर्न में ये शामिल हैं:

  • रजिस्ट्रेशन के दौरान, उपयोगकर्ता के दूसरे फ़ैक्टर को रजिस्टर करें. अगर आपके ऐप्लिकेशन में सभी उपयोगकर्ताओं के लिए, कई तरीकों से पुष्टि करने की ज़रूरत है, तो इस तरीके का इस्तेमाल करें.

  • रजिस्ट्रेशन के दौरान, दूसरे फ़ैक्टर को रजिस्टर करने का विकल्प दें, जिसे स्किप किया जा सकता है. अगर आपको अपने ऐप्लिकेशन में कई तरीकों से पुष्टि करने की सुविधा को बढ़ावा देना है, लेकिन उसे ज़रूरी नहीं बनाना है, तो इस तरीके का इस्तेमाल किया जा सकता है.

  • साइन-अप स्क्रीन के बजाय, उपयोगकर्ता के खाते या प्रोफ़ाइल मैनेजमेंट पेज से दूसरा फ़ैक्टर जोड़ने की सुविधा दें. इससे रजिस्ट्रेशन की प्रोसेस के दौरान होने वाली परेशानी कम हो जाती है. साथ ही, सुरक्षा को लेकर संवेदनशील उपयोगकर्ताओं के लिए, कई तरीकों से पुष्टि करने की सुविधा उपलब्ध रहती है.

  • जब उपयोगकर्ता ज़्यादा सुरक्षा की ज़रूरी शर्तों वाली सुविधाओं को ऐक्सेस करना चाहता है, तो उसे धीरे-धीरे दूसरा फ़ैक्टर जोड़ना पड़ता है.

उपयोगकर्ताओं को टीओटीपी एमएफ़ए में रजिस्टर करना

अपने ऐप्लिकेशन के लिए, दूसरे फ़ैक्टर के तौर पर टीओटीपी एमएफ़ए को चालू करने के बाद, उपयोगकर्ताओं को टीओटीपी एमएफ़ए में रजिस्टर करने के लिए, क्लाइंट-साइड लॉजिक लागू करें:

  1. ज़रूरी एमएफ़ए क्लास और फ़ंक्शन इंपोर्ट करें:

    import {
  multiFactor,
  TotpMultiFactorGenerator,
  TotpSecret,
  getAuth,
} from "firebase/auth";

  2. उपयोगकर्ता की फिर से पुष्टि करें.

  3. पुष्टि किए गए उपयोगकर्ता के लिए, टीओटीपी पासकोड जनरेट करना:

    // Generate a TOTP secret.
const multiFactorSession = await multiFactor(currentUser).getSession();
const totpSecret = await TotpMultiFactorGenerator.generateSecret(
  multiFactorSession
);

  4. उपयोगकर्ता को पासवर्ड दिखाएं और उसे अपने ऐथेंटिकेटर ऐप्लिकेशन में डालने के लिए कहें.

    कई ऑथेंटिकेटर ऐप्लिकेशन की मदद से, उपयोगकर्ता Google Authenticator के साथ काम करने वाली कुंजी के यूआरआई को दिखाने वाले क्यूआर कोड को स्कैन करके, तुरंत नए टीओटीपी पासवर्ड जोड़ सकते हैं. इस काम के लिए क्यूआर कोड जनरेट करने के लिए, generateQrCodeUrl() का इस्तेमाल करके यूआरआई जनरेट करें. इसके बाद, अपनी पसंद की क्यूआर कोड लाइब्रेरी का इस्तेमाल करके उसे कोड में बदलें. उदाहरण के लिए:

    const totpUri = totpSecret.generateQrCodeUrl(
    currentUser.email,
    "Your App's Name"
);
await QRExampleLib.toCanvas(totpUri, qrElement);

    क्यूआर कोड दिखाने या न दिखाने के बावजूद, पुष्टि करने वाले उन ऐप्लिकेशन के साथ काम करने के लिए, हमेशा पासकोड दिखाएं जो क्यूआर कोड नहीं पढ़ सकते:

    // Also display this key:
const secret = totpSecret.secretKey;

    उपयोगकर्ता अपने Authenticator ऐप्लिकेशन में अपने पासवर्ड जोड़ने के बाद, यह टोटीपी जनरेट करना शुरू कर देगा.

  5. उपयोगकर्ता को पुष्टि करने वाले ऐप्लिकेशन पर दिखने वाला टीओटीपी टाइप करने के लिए कहें और फिर एमएफ़ए के लिए रजिस्टर करने की प्रोसेस पूरी करने के लिए उसका इस्तेमाल करें:

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

// Finalize the enrollment.
const multiFactorAssertion = TotpMultiFactorGenerator.assertionForEnrollment(
  totpSecret,
  verificationCode
);
await multiFactor(currentUser).enroll(multiFactorAssertion, mfaDisplayName);

उपयोगकर्ताओं को दूसरे तरीके से साइन इन करने की सुविधा देना

उपयोगकर्ताओं को टीओटीपी एमएफ़ए की मदद से साइन इन कराने के लिए, इस कोड का इस्तेमाल करें:

  1. ज़रूरी एमएफ़ए क्लास और फ़ंक्शन इंपोर्ट करें:

    import {
    getAuth,
    getMultiFactorResolver,
    TotpMultiFactorGenerator,
} from "firebase/auth";

  2. signInWith- में से किसी एक तरीके को वैसे ही कॉल करें जैसे एमएफ़ए का इस्तेमाल न करने पर किया जाता है. (उदाहरण के लिए, signInWithEmailAndPassword().) अगर इस तरीके से auth/multi-factor-auth-required गड़बड़ी का मैसेज मिलता है, तो अपने ऐप्लिकेशन का एमएफ़ए फ़्लो शुरू करें.

    try {
    const userCredential = await signInWithEmailAndPassword(
        getAuth(),
        email,
        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 (error) {
    switch (error.code) {
        case "auth/multi-factor-auth-required":
            // Initiate your second factor sign-in flow. (See next step.)
            // ...
            break;
        case ...:  // Handle other errors, such as wrong passwords.
            break;
    }
}

  3. आपके ऐप्लिकेशन के एमएफ़ए फ़्लो में, उपयोगकर्ता को सबसे पहले वह दूसरा तरीका चुनने के लिए कहा जाना चाहिए जिसका इस्तेमाल करना है. MultiFactorResolver इंस्टेंस की hints प्रॉपर्टी की जांच करके, इस्तेमाल किए जा सकने वाले दूसरे फ़ैक्टर की सूची देखी जा सकती है:

    const mfaResolver = getMultiFactorResolver(getAuth(), error);
const enrolledFactors = mfaResolver.hints.map(info => info.displayName);

  4. अगर उपयोगकर्ता टीओटीपी का इस्तेमाल करना चाहता है, तो उसे अपने पुष्टि करने वाले ऐप्लिकेशन पर दिखने वाला टीओटीपी टाइप करने के लिए कहें. इसके बाद, साइन इन करने के लिए उसका इस्तेमाल करें:

    switch (mfaResolver.hints[selectedIndex].factorId) {
    case TotpMultiFactorGenerator.FACTOR_ID:
        const otpFromAuthenticator = // OTP typed by the user.
        const multiFactorAssertion =
            TotpMultiFactorGenerator.assertionForSignIn(
                mfaResolver.hints[selectedIndex].uid,
                otpFromAuthenticator
            );
        try {
            const userCredential = await mfaResolver.resolveSignIn(
                multiFactorAssertion
            );
            // Successfully signed in!
        } catch (error) {
            // Invalid or expired OTP.
        }
        break;
    case PhoneMultiFactorGenerator.FACTOR_ID:
        // Handle SMS second factor.
        break;
    default:
        // Unsupported second factor?
        break;
}

टीओटीपी एमएफ़ए से नाम हटाना

इस सेक्शन में, उपयोगकर्ता को टीओटीपी एमएफ़ए से अनरॉल करने के तरीके के बारे में बताया गया है.

अगर किसी उपयोगकर्ता ने एमएफ़ए के एक से ज़्यादा विकल्पों के लिए साइन अप किया है और उसने हाल ही में चालू किए गए विकल्प से ऑप्ट आउट किया है, तो उसे auth/user-token-expired दिखेगा और उसे लॉग आउट कर दिया जाएगा. उपयोगकर्ता को फिर से साइन इन करना होगा और अपने मौजूदा क्रेडेंशियल की पुष्टि करनी होगी. उदाहरण के लिए, ईमेल पता और पासवर्ड.

उपयोगकर्ता को अनरॉल करने, गड़बड़ी को ठीक करने, और फिर से पुष्टि करने की प्रोसेस को ट्रिगर करने के लिए, यहां दिए गए कोड का इस्तेमाल करें:

import {
    EmailAuthProvider,
    TotpMultiFactorGenerator,
    getAuth,
    multiFactor,
    reauthenticateWithCredential,
} from "firebase/auth";

try {
    // Unenroll from TOTP MFA.
    await multiFactor(currentUser).unenroll(mfaEnrollmentId);
} catch  (error) {
    if (error.code === 'auth/user-token-expired') {
        // 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.

        const credential = EmailAuthProvider.credential(email, password);
        await reauthenticateWithCredential(
            currentUser,
            credential
        );
    }
}

आगे क्या करना है