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

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

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

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

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

    • फ़ोन नंबर से पुष्टि करना
    • पहचान छिपाकर पुष्टि करना
    • कस्टम ऑथेंटिकेशन टोकन
    • Apple Game Center

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

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

    टीओटीपी एमएफ़ए की सुविधा, सिर्फ़ Android SDK के वर्शन v22.1.0 और इसके बाद के वर्शन पर काम करती है.

टीओटीपी एमएफ़ए की सुविधा चालू करना

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

      टीओटीपी यह पक्का करते हैं कि जब दो पक्ष (पुष्टि करने वाला और पुष्टि करने वाला) एक ही समयसीमा (आम तौर पर 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. उपयोगकर्ता की फिर से पुष्टि करें.

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

    // Generate a TOTP secret.
Firebase.auth.currentUser.multiFactor.session
    .addOnSuccessListener { multiFactorSession ->
        TotpMultiFactorGenerator.generateSecret(multiFactorSession)
            .addOnSuccessListener { totpSecret ->
                // Display the secret to the user and prompt them to
                // enter it into their authenticator app. (See the next
                // step.)
            }
    }

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

    // Display this key:
val secret = totpSecret.sharedSecretKey

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

    val qrCodeUri = totpSecret.generateQrCodeUrl(
    currentUser.email ?: "default account",
    "Your App Name")
totpSecret.openInOtpApp(qrCodeUri)

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

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

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

// Finalize the enrollment.
val multiFactorAssertion = TotpMultiFactorGenerator
    .getAssertionForEnrollment(totpSecret, verificationCode)
Firebase.auth.currentUser.multiFactor.enroll(multiFactorAssertion, "TOTP")
    .addOnSuccessListener {
        // Enrollment complete.
    }

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

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

  1. signInWith के किसी एक तरीके को कॉल करें, जैसा कि एमएफ़ए का इस्तेमाल न करने पर किया जाता है. उदाहरण के लिए, signInWithEmailAndPassword(). अगर यह तरीका FirebaseAuthMultiFactorException दिखाता है, तो अपने ऐप्लिकेशन का एमएफ़ए फ़्लो शुरू करें.

    Firebase.auth.signInWithEmailAndPassword(email, password)
    .addOnSuccessListener { result ->
        // 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.)

        // ...
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthMultiFactorException -> {
                // Initiate your second factor sign-in flow. (See next step.)
                // ...
            }
        }
    }

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

    val enrolledFactors = exception.resolver.hints.map { it.displayName }

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

    when (exception.resolver.hints[selectedIndex].factorId) {
    TotpMultiFactorGenerator.FACTOR_ID -> {
        val otpFromAuthenticator = // OTP typed by the user.
        val assertion = TotpMultiFactorGenerator.getAssertionForSignIn(
            exception.resolver.hints[selectedIndex].uid,
            otpFromAuthenticator
        )
        exception.resolver.resolveSignIn(assertion)
            .addOnSuccessListener { result ->
                // Successfully signed in!
            }
            .addOnFailureListener { resolveError ->
                // Invalid or expired OTP.
            }
    }
    PhoneMultiFactorGenerator.FACTOR_ID -> {
        // Handle SMS second factor.
    }
}

टीओटीपी एमएफ़ए से ऑप्ट आउट करना

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

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

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

Firebase.auth.currentUser.multiFactor.unenroll(mfaEnrollmentId)
    .addOnSuccessListener {
        // Second factor unenrolled.
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthInvalidUserException -> {
                // Second factor unenrolled. 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.
                val credential = EmailAuthProvider.getCredential(email, password)
                currentUser.reauthenticate(credential)
                    .addOnSuccessListener { 
                        // Success!
                    }
                    .addOnFailureListener { 
                        // Bad email address and password combination.
                    }
            }
        }
    }

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