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

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

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

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

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

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

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

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

    TOTP MFA सिर्फ़ Android SDK वर्शन v22.1.0 और इसके बाद वाले वर्शन पर काम करता है.

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. उपयोगकर्ता की फिर से पुष्टि करें.

  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. उपयोगकर्ता को सीक्रेट बताएं और उसे Authenticator ऐप्लिकेशन में इसे डालने के लिए कहें:

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

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

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

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

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

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

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

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

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

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

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

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

    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 की सदस्यता छोड़ें

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

अगर किसी उपयोगकर्ता ने एक से ज़्यादा 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.
                    }
            }
        }
    }

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