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

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

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

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

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

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

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

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

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

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 सेकंड) में ओटीपी जनरेट करते हैं, तो वे एक ही पासवर्ड जनरेट करते हैं. हालांकि, दोनों पक्षों और लोगों के जवाब देने के समय के बीच समय के अंतर को शामिल करने के लिए, आप TOTP सेवा को कॉन्फ़िगर कर सकते हैं, ताकि आस-पास की विंडो से भी TOTP स्वीकार किया जा सके.

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

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

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

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

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

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

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

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

अगर आपको अपने ऐप्लिकेशन के लिए दूसरे चरण के तौर पर TOTP MFA को चालू करना है, तो उपयोगकर्ताओं को TOTP 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)

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

  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
}

टीओटीपी एमएफ़ए से ऑप्ट आउट करना

इस सेक्शन में बताया गया है कि TOTP 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.
}

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