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

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

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

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

1. कम से कम एक ऐसी सेवा चालू करें जो एमएफ़ए की सुविधा देती हो. ध्यान दें कि यहां दिए गए इनके अलावा, सभी प्रोवाइडर के लिए एमएफ़ए की सुविधा उपलब्ध है:

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

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

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

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

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

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

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

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

   TOTP MFA की सुविधा, 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: यह बताता है कि टीओटीपी स्वीकार करने के लिए, आस-पास के कितने टाइम-विंडो इंटरवल इस्तेमाल किए जा सकते हैं. इनकी संख्या शून्य से दस तक हो सकती है. डिफ़ॉल्ट रूप से, यह पांच पर सेट होता है.

     टीओटीपी इस तरह काम करते हैं कि जब दो पक्ष (प्रूवर और पुष्टि करने वाला) एक ही समय सीमा (आम तौर पर 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: टाइम-विंडो इंटरवल की संख्या, जो शून्य से लेकर दस तक होती है. डिफ़ॉल्ट रूप से, यह पांच पर सेट होता है.

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

पंजीकरण का पैटर्न चुनें

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

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

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

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

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

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

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

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

   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. उपयोगकर्ता को सीक्रेट कोड दिखाएं और उसे अपने पुष्टि करने वाले ऐप्लिकेशन में डालने के लिए कहें.

   कई Authenticator ऐप्लिकेशन में, उपयोगकर्ता 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;
   

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

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. ज़रूरी MFA क्लास और फ़ंक्शन इंपोर्ट करें:

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

2. signInWith में से किसी एक तरीके का इस्तेमाल करके कॉल करें. ऐसा तब भी किया जाता है, जब आपने MFA का इस्तेमाल नहीं किया होता. (उदाहरण के लिए, 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. आपके ऐप्लिकेशन में, एमएफ़ए फ़्लो के तहत उपयोगकर्ता को सबसे पहले दूसरा फ़ैक्टर चुनने के लिए कहा जाना चाहिए. hints इंस्टेंस की MultiFactorResolver प्रॉपर्टी की जांच करके, पुष्टि के लिए इस्तेमाल किए जा सकने वाले दूसरे तरीकों की सूची देखी जा सकती है:

   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
        );
    }
}

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

• Admin SDK की मदद से, प्रोग्राम के हिसाब से मल्टी-फ़ैक्टर ऑथेंटिकेशन का इस्तेमाल करने वाले लोगों को मैनेज करें.