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

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

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

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

  1. MFA के साथ काम करने वाली कम से कम एक कंपनी चालू करें. ध्यान दें कि सभी कंपनियां नीचे दिए गए सहायता MFA के अलावा:

    • फ़ोन से पुष्टि
    • अनाम पुष्टि
    • पुष्टि करने वाले कस्टम टोकन
    • Apple गेम सेंटर

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

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

    TOTP MFA सिर्फ़ मॉड्यूलर वेब SDK टूल, वर्शन v9.19.1, और पढ़ें.

TOTP MFA चालू करें

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

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

डिवाइस रजिस्टर करने का कोई पैटर्न चुनें

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

  • रजिस्ट्रेशन के हिस्से के तौर पर, उपयोगकर्ता के दूसरे चरण को रजिस्टर करें. इसका इस्तेमाल करें ���� तरीका इस्तेमाल करें.

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

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

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

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

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

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

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

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

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

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

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

    पुष्टि करने वाले कई ऐप्लिकेशन की मदद से, लोग तुरंत नए TOTP सीक्रेट जोड़ सकते हैं वह क्यूआर कोड स्कैन कर रहा है जो 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;

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

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

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

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