अपने 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.
                    }
            }
        }
    }

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