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

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

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

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

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

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

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

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

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

TOTP MFA चालू करें

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

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

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

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

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

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

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

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

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

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

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

  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)

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

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

TOTP MFA से टास्क छोड़ें

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

अगर किसी उपयोगकर्ता ने एमएफ़ए के कई विकल्पों के लिए साइन अप किया है और वह हाल ही में चालू किए गए विकल्प से ऑप्ट आउट करता है, तो उसे 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.
                    }
            }
        }
    }

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