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

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

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

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

1. MFA की सुविधा देने वाली कम से कम एक सेवा देने वाली कंपनी चालू करें. ध्यान दें कि इन कंपनियों को छोड़कर, सभी कंपनियां MFA की सुविधा देती हैं:

   • फ़ोन पुष्टि
   • पहचान छिपाकर दी गई पुष्टि
   • पुष्टि करने के लिए पसंद के मुताबिक टोकन
   • Apple गेम सेंटर

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

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

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

TOTP MFA चालू करें

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

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

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

   TOTP MFA सिर्फ़ Firebase एडमिन 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 का इस्तेमाल करके, TOTP MFA को चालू करने के लिए, इसे चलाएं:

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 सेकंड की अवधि) में ओटीपी जनरेट करते हैं, तब वे एक ही पासवर्ड जनरेट करते हैं. हालांकि, पार्टी और लोगों के जवाब देने के समय के बीच क्लॉक ड्रिप को अडजस्ट करने के लिए, टीओटीपी सेवा को कॉन्फ़िगर किया जा सकता है, ताकि पास की विंडो से टीओटीपी को भी स्वीकार किया जा सके.

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

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

• रजिस्ट्रेशन के दौरान, उपयोगकर्ता के दूसरे चरण को रजिस्टर करें. अगर आपके ऐप्लिकेशन को सभी उपयोगकर्ताओं के लिए बहु-स्तरीय पुष्टि (MFA) की ज़रूरत हो, तो यह तरीका अपनाएं.

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

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

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

TOTP MFA में उपयोगकर्ताओं को रजिस्टर करें

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

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. उपयोगकर्ता को, अपने पुष्टि करने वाले ऐप्लिकेशन पर दिखाया गया टीओटीपी टाइप करने का अनुरोध करें. इसके बाद, MFA में रजिस्टर करने की प्रक्रिया पूरी करने के लिए इसका इस्तेमाल करें:

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

दूसरे तरीके से उपयोगकर्ताओं में साइन इन करना

TOTP MFA वाले उपयोगकर्ताओं में साइन इन करने के लिए, इस कोड का इस्तेमाल करें:

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

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

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

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

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

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

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

TOTP MFA की सदस्यता छोड़ें

इस सेक्शन में बताया गया है कि TOTP MFA की सदस्यता छोड़ने वाले उपयोगकर्ता को कैसे मैनेज किया जाए.

अगर किसी उपयोगकर्ता ने एक से ज़्यादा MFA विकल्पों के लिए साइन अप किया है और वह हाल ही में चालू किए गए विकल्प से सदस्यता छोड़ते हैं, तो उसे 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
        );
    }
}

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

• एडमिन SDK की मदद से, प्रोग्राम के हिसाब से कई तरीकों से काम करने वाले उपयोगकर्ताओं को मैनेज करें.