अपने iOS ऐप्लिकेशन में TOTP बहु-स्तरीय पुष्टि (MFA) जोड़ें

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

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

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

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

    • फ़ोन से पुष्टि करने की सुविधा
    • अनाम तरीके से पुष्टि करने की सुविधा
    • कस्टम ऑथ टोकन
    • Apple Game Center

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

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

    टीओटीपी एमएफ़ए की सुविधा, सिर्फ़ Apple SDK के v10.12.0 और इसके बाद के वर्शन पर काम करती है. साथ ही, यह सुविधा सिर्फ़ iOS पर काम करती है.

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

टीओटीपी को दूसरे चरण के तौर पर चालू करने के लिए, 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.
guard let mfaSession = try? await currentUser.multiFactor.session() else { return }
guard let totpSecret = try? await TOTPMultiFactorGenerator.generateSecret(with: mfaSession) else { return }

// Display the secret to the user and prompt them to enter it into their
// authenticator app. (See the next step.)

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

    // Display this key:
let secret = totpSecret.sharedSecretKey()

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

    let otpAuthUri = totpSecret.generateQRCodeURL(
    withAccountName: currentUser.email ?? "default account",
    issuer: "Your App Name")
totpSecret.openInOTPApp(withQRCodeURL: otpAuthUri)

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

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

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

// Finalize the enrollment.
let multiFactorAssertion = TOTPMultiFactorGenerator.assertionForEnrollment(
    with: totpSecret,
    oneTimePassword: verificationCode)
do {
    try await currentUser.multiFactor.enroll(
        with: multiFactorAssertion,
        displayName: "TOTP")
} catch {
    // Wrong or expired OTP. Re-prompt the user.
}

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

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

  1. signIn(with...:)- तरीकों में से किसी एक को कॉल करें. जैसे, signIn(withEmail:password:). अगर इस तरीके से, secondFactorRequired कोड वाली गड़बड़ी होती है, तो अपने ऐप्लिकेशन का एमएफ़ए फ़्लो शुरू करें.

    do {
    let authResult = try await Auth.auth().signIn(withEmail: email, password: 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 let error as AuthErrorCode where error.code == .secondFactorRequired {
    // Initiate your second factor sign-in flow. (See next step.)
    // ...
} catch {
    // Other auth error.
    throw error
}

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

    let mfaKey = AuthErrorUserInfoMultiFactorResolverKey
guard let resolver = error.userInfo[mfaKey] as? MultiFactorResolver else { return }
let enrolledFactors = resolver.hints.map(\.displayName)

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

    let multiFactorInfo = resolver.hints[selectedIndex]
switch multiFactorInfo.factorID {
case TOTPMultiFactorID:
    let otpFromAuthenticator = // OTP typed by the user.
    let assertion = TOTPMultiFactorGenerator.assertionForSignIn(
        withEnrollmentID: multiFactorInfo.uid,
        oneTimePassword: otpFromAuthenticator)
    do {
        let authResult = try await resolver.resolveSignIn(with: assertion)
    } catch {
        // Wrong or expired OTP. Re-prompt the user.
    }
default:
    return
}

टीओटीपी एमएफ़ए से एनरॉलमेंट रद्द करना

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

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

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

guard let currentUser = Auth.auth().currentUser else { return }

// Prompt the user to select a factor to unenroll, from this array:
currentUser.multiFactor.enrolledFactors

// ...

// Unenroll the second factor.
let multiFactorInfo = currentUser.multiFactor.enrolledFactors[selectedIndex]
do {
    try await currentUser.multiFactor.unenroll(with: multiFactorInfo)
} catch let error as AuthErrorCode where error.code == .invalidUserToken {
    // Second factor unenrolled, but the user was signed out. Re-authenticate
    // them.
}

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