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

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

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

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

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

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

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

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

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

टीओटीपी MFA की सुविधा चालू करना

टीओटीपी को दूसरे चरण के तौर पर चालू करने के लिए, Admin SDK का इस्तेमाल करें या प्रोजेक्ट कॉन्फ़िगरेशन REST एंडपॉइंट को कॉल करें.

Admin SDK का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

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

    टीओटीपी MFA की सुविधा, सिर्फ़ 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 का इस्तेमाल करके, टीओटीपी 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) को बढ़ावा देना है, लेकिन इसे ज़रूरी नहीं बनाना है, तो इस तरीके का इस्तेमाल किया जा सकता है.

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

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

उपयोगकर्ताओं को टीओटीपी MFA में एनरॉल करना

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

  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. उपयोगकर्ता से उसके ऑथेंटिकेटर ऐप्लिकेशन में दिखने वाला टीओटीपी टाइप करने के लिए कहें. साथ ही, इसका इस्तेमाल करके, MFA एनरॉलमेंट की प्रोसेस पूरी करें:

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

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

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

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

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

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

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

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

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