Apple और C++ का उपयोग करके प्रमाणित करें

आप अपने उपयोगकर्ताओं को एंड-टू-एंड OAuth 2.0 साइन-इन प्रवाह करने के लिए Firebase SDK का उपयोग करके उनके Apple ID का उपयोग करके Firebase के साथ प्रमाणित करने दे सकते हैं।

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

Apple का उपयोग करने वाले उपयोगकर्ताओं में साइन इन करने के लिए, पहले Apple की डेवलपर साइट पर Apple के साथ साइन इन करें, फिर अपने Firebase प्रोजेक्ट के लिए Apple को साइन-इन प्रदाता के रूप में सक्षम करें।

Apple डेवलपर प्रोग्राम में शामिल हों

Apple के साथ साइन इन केवल Apple डेवलपर प्रोग्राम के सदस्यों द्वारा कॉन्फ़िगर किया जा सकता है।

Apple के साथ साइन इन कॉन्फ़िगर करें

Apple साइन इन सक्षम होना चाहिए और आपके फायरबेस प्रोजेक्ट में ठीक से कॉन्फ़िगर किया जाना चाहिए। कॉन्फ़िगरेशन Android और Apple प्लेटफ़ॉर्म पर भिन्न होता है। आगे बढ़ने से पहले कृपया Apple प्लेटफॉर्म और/या Android गाइड के "कॉन्फ़िगर साइन इन Apple" अनुभाग का पालन करें।

साइन-इन प्रदाता के रूप में Apple को सक्षम करें

  1. Firebase कंसोल में, प्रामाणिक अनुभाग खोलें। साइन इन विधि टैब पर, Apple प्रदाता को सक्षम करें।
  2. Apple साइन-इन प्रदाता सेटिंग कॉन्फ़िगर करें:
    1. यदि आप अपने ऐप को केवल Apple प्लेटफ़ॉर्म पर परिनियोजित कर रहे हैं, तो आप सेवा ID, Apple टीम ID, निजी कुंजी और कुंजी ID फ़ील्ड को खाली छोड़ सकते हैं।

    2. Android उपकरणों पर समर्थन के लिए:
      1. अपने Android प्रोजेक्ट में Firebase जोड़ें । जब आप अपने ऐप को फायरबेस कंसोल में सेट करते हैं तो अपने ऐप के SHA-1 हस्ताक्षर को पंजीकृत करना सुनिश्चित करें।
      2. Firebase कंसोल में, प्रामाणिक अनुभाग खोलें। साइन इन विधि टैब पर, Apple प्रदाता को सक्षम करें। पिछले अनुभाग में आपके द्वारा बनाई गई सेवा आईडी निर्दिष्ट करें। साथ ही, OAuth कोड फ़्लो कॉन्फ़िगरेशन अनुभाग में, अपनी Apple टीम ID और निजी कुंजी और कुंजी ID निर्दिष्ट करें जिसे आपने पिछले अनुभाग में बनाया था।

Apple की अनाम डेटा आवश्यकताओं का अनुपालन करें

Apple के साथ साइन इन करें उपयोगकर्ताओं को साइन इन करते समय, उनके ईमेल पते सहित, उनके डेटा को गुमनाम करने का विकल्प देता है। इस विकल्प को चुनने वाले उपयोगकर्ताओं के ईमेल पते privaterelay.appleid.com डोमेन के साथ होते हैं। जब आप अपने ऐप में Apple के साथ साइन इन का उपयोग करते हैं, तो आपको इन अज्ञात Apple ID के संबंध में Apple की किसी भी लागू डेवलपर नीतियों या शर्तों का पालन करना होगा।

इसमें किसी अज्ञात Apple ID के साथ सीधे तौर पर पहचान करने वाली व्यक्तिगत जानकारी को संबद्ध करने से पहले आवश्यक उपयोगकर्ता सहमति प्राप्त करना शामिल है। फायरबेस प्रमाणीकरण का उपयोग करते समय, इसमें निम्नलिखित क्रियाएं शामिल हो सकती हैं:

  • एक ईमेल पते को एक अनाम Apple ID या इसके विपरीत लिंक करें।
  • फ़ोन नंबर को किसी अज्ञात Apple ID या इसके विपरीत लिंक करें
  • एक गैर-अनाम सामाजिक क्रेडेंशियल (Facebook, Google, आदि) को एक अज्ञात Apple ID या इसके विपरीत लिंक करें।

उपरोक्त सूची संपूर्ण नहीं है। यह सुनिश्चित करने के लिए कि आपका ऐप Apple की आवश्यकताओं को पूरा करता है, अपने डेवलपर खाते के सदस्यता अनुभाग में Apple डेवलपर प्रोग्राम लाइसेंस अनुबंध देखें।

firebase::auth::Auth क्लास तक पहुंचें

Auth क्लास सभी एपीआई कॉल्स के लिए गेटवे है।
  1. प्रामाणिक और ऐप शीर्षलेख फ़ाइलें जोड़ें:
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. अपने इनिशियलाइज़ेशन कोड में, एक firebase::App क्लास बनाएँ।
    #if defined(__ANDROID__)
  firebase::App* app =
      firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
#else
  firebase::App* app = firebase::App::Create(firebase::AppOptions());
#endif  // defined(__ANDROID__)
  3. अपने firebase::App के लिए firebase::auth::Auth वर्ग प्राप्त करें। App और Auth के बीच वन-टू-वन मैपिंग है।
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

फायरबेस एसडीके के साथ साइन-इन प्रवाह को संभालें

Apple के साथ साइन-इन करने की प्रक्रिया Apple और Android प्लेटफ़ॉर्म में भिन्न होती है।

Apple प्लेटफॉर्म पर

अपने उपयोगकर्ताओं को आपके C++ कोड से मंगाए गए Apple साइन इन ऑब्जेक्टिव-सी SDK के माध्यम से Firebase के साथ प्रमाणित करें।

  1. प्रत्येक साइन-इन अनुरोध के लिए, एक यादृच्छिक स्ट्रिंग उत्पन्न करें—एक "नॉन्स"—जिसका उपयोग आप यह सुनिश्चित करने के लिए करेंगे कि आपको प्राप्त होने वाला आईडी टोकन विशेष रूप से आपके ऐप के प्रमाणीकरण अनुरोध के जवाब में प्रदान किया गया था। रीप्ले हमलों को रोकने के लिए यह कदम महत्वपूर्ण है।

      - (NSString *)randomNonce:(NSInteger)length {
    NSAssert(length > 0, @"Expected nonce to have positive length");
    NSString *characterSet = @"0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._";
    NSMutableString *result = [NSMutableString string];
    NSInteger remainingLength = length;

    while (remainingLength > 0) {
      NSMutableArray *randoms = [NSMutableArray arrayWithCapacity:16];
      for (NSInteger i = 0; i < 16; i++) {
        uint8_t random = 0;
        int errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random);
        NSAssert(errorCode == errSecSuccess, @"Unable to generate nonce: OSStatus %i", errorCode);

        [randoms addObject:@(random)];
      }

      for (NSNumber *random in randoms) {
        if (remainingLength == 0) {
          break;
        }

        if (random.unsignedIntValue < characterSet.length) {
          unichar character = [characterSet characterAtIndex:random.unsignedIntValue];
          [result appendFormat:@"%C", character];
          remainingLength--;
        }
      }
    }
  }

    आप अपने साइन-इन अनुरोध के साथ नॉन का SHA256 हैश भेजेंगे, जिसे प्रतिक्रिया में Apple अपरिवर्तित पारित करेगा। फायरबेस मूल नॉन को हैश करके और Apple द्वारा पास किए गए मान से तुलना करके प्रतिक्रिया को मान्य करता है।

  2. Apple के साइन-इन प्रवाह को प्रारंभ करें, जिसमें आपके अनुरोध में गैर का SHA256 हैश और Apple की प्रतिक्रिया को संभालने वाले प्रतिनिधि वर्ग शामिल हैं (अगला चरण देखें):

      - (void)startSignInWithAppleFlow {
    NSString *nonce = [self randomNonce:32];
    self.currentNonce = nonce;
    ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
    ASAuthorizationAppleIDRequest *request = [appleIDProvider createRequest];
    request.requestedScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
    request.nonce = [self stringBySha256HashingString:nonce];

    ASAuthorizationController *authorizationController =
        [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[request]];
    authorizationController.delegate = self;
    authorizationController.presentationContextProvider = self;
    [authorizationController performRequests];
  }

  - (NSString *)stringBySha256HashingString:(NSString *)input {
    const char *string = [input UTF8String];
    unsigned char result[CC_SHA256_DIGEST_LENGTH];
    CC_SHA256(string, (CC_LONG)strlen(string), result);

    NSMutableString *hashed = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
    for (NSInteger i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
      [hashed appendFormat:@"%02x", result[i]];
    }
    return hashed;
  }

  3. ASAuthorizationControllerDelegate' के अपने कार्यान्वयन में Apple की प्रतिक्रिया को संभालें। यदि साइन-इन सफल रहा, तो फायरबेस के साथ प्रमाणित करने के लिए बिना हैश किए हुए गैर के साथ Apple की प्रतिक्रिया से आईडी टोकन का उपयोग करें:

      - (void)authorizationController:(ASAuthorizationController *)controller
     didCompleteWithAuthorization:(ASAuthorization *)authorization API_AVAILABLE(ios(13.0)) {
    if ([authorization.credential isKindOfClass:[ASAuthorizationAppleIDCredential class]]) {
      ASAuthorizationAppleIDCredential *appleIDCredential = authorization.credential;
      NSString *rawNonce = self.currentNonce;
      NSAssert(rawNonce != nil, @"Invalid state: A login callback was received, but no login request was sent.");

      if (appleIDCredential.identityToken == nil) {
        NSLog(@"Unable to fetch identity token.");
        return;
      }

      NSString *idToken = [[NSString alloc] initWithData:appleIDCredential.identityToken
                                                encoding:NSUTF8StringEncoding];
      if (idToken == nil) {
        NSLog(@"Unable to serialize id token from data: %@", appleIDCredential.identityToken);
      }
    }

  4. फायरबेस क्रेडेंशियल बनाने और फायरबेस में साइन इन करने के लिए परिणामी टोकन स्ट्रिंग और मूल गैर का उपयोग करें।

    firebase::auth::OAuthProvider::GetCredential(
        /*provider_id=*/"apple.com", token, nonce,
        /*access_token=*/nullptr);

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

  5. उसी पैटर्न का उपयोग Reauthenticate के साथ किया जा सकता है जिसका उपयोग संवेदनशील संचालन के लिए नए क्रेडेंशियल्स को पुनः प्राप्त करने के लिए किया जा सकता है जिसके लिए हाल ही में लॉगिन की आवश्यकता होती है।

    firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);

  6. किसी खाते को Apple साइन इन से लिंक करने के लिए समान पैटर्न का उपयोग किया जा सकता है। हालाँकि, आपको एक त्रुटि का सामना करना पड़ सकता है जब एक मौजूदा फायरबेस खाता पहले से ही उस ऐप्पल खाते से जुड़ा हुआ है जिसे आप लिंक करने का प्रयास कर रहे हैं। जब ऐसा होता है तो भविष्य kAuthErrorCredentialAlreadyInUse की स्थिति लौटाएगा और AuthResult में एक मान्य credential हो सकता है। इस क्रेडेंशियल का उपयोग Apple से जुड़े खाते में SignInAndRetrieveDataWithCredential के माध्यम से साइन इन करने के लिए किया जा सकता है, बिना किसी अन्य Apple साइन इन टोकन और नॉन को जेनरेट करने की आवश्यकता के।

    firebase::Future<firebase::auth::AuthResult> link_result =
    auth->current_user().LinkWithCredential(credential);

// To keep example simple, wait on the current thread until call completes.
while (link_result.status() == firebase::kFutureStatusPending) {
  Wait(100);
}

// Determine the result of the link attempt
if (link_result.error() == firebase::auth::kAuthErrorNone) {
  // user linked correctly.
} else if (link_result.error() ==
               firebase::auth::kAuthErrorCredentialAlreadyInUse &&
           link_result.result()
               ->additional_user_info.updated_credential.is_valid()) {
  // Sign In with the new credential
  firebase::Future<firebase::auth::AuthResult> result =
      auth->SignInAndRetrieveDataWithCredential(
          link_result.result()->additional_user_info.updated_credential);
} else {
  // Another link error occurred.
}

Android पर

एंड्रॉइड पर, वेब-आधारित जेनेरिक OAuth लॉगिन को अपने ऐप में फायरबेस एसडीके का उपयोग करके एंड टू एंड साइन-इन प्रवाह को पूरा करने के लिए अपने उपयोगकर्ताओं को फायरबेस के साथ प्रमाणित करें।

फायरबेस एसडीके के साथ साइन-इन प्रवाह को संभालने के लिए, इन चरणों का पालन करें:

  1. Apple के लिए उपयुक्त प्रदाता ID के साथ कॉन्फ़िगर किए गए FederatedOAuthProviderData का एक उदाहरण बनाएँ।

    firebase::auth::FederatedOAuthProviderData provider_data("apple.com");

  2. वैकल्पिक: डिफ़ॉल्ट से परे अतिरिक्त OAuth 2.0 स्कोप निर्दिष्ट करें जिसे आप प्रमाणीकरण प्रदाता से अनुरोध करना चाहते हैं।

    provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");

  3. वैकल्पिक: यदि आप Apple की साइन-इन स्क्रीन को अंग्रेजी के अलावा किसी अन्य भाषा में प्रदर्शित करना चाहते हैं, तो locale पैरामीटर सेट करें। समर्थित स्थानों के लिए Apple डॉक्स के साथ साइन इन देखें।

    // Localize to French.
provider_data.custom_parameters["language"] = "fr";
```

  4. एक बार आपका प्रदाता डेटा कॉन्फ़िगर हो जाने के बाद, FederatedOAuthProvider बनाने के लिए इसका उपयोग करें।

    // Construct a FederatedOAuthProvider for use in Auth methods.
firebase::auth::FederatedOAuthProvider provider(provider_data);

  5. प्रामाणिक प्रदाता वस्तु का उपयोग करके फायरबेस के साथ प्रमाणित करें। ध्यान दें कि अन्य FirebaseAuth संचालन के विपरीत, यह एक वेब दृश्य पॉप अप करके आपके UI को नियंत्रित करेगा जिसमें उपयोगकर्ता अपनी साख दर्ज कर सकता है।

    साइन इन फ्लो शुरू करने के लिए, signInWithProvider को कॉल करें:

    firebase::Future<firebase::auth::AuthResult> result =
  auth->SignInWithProvider(provider_data);

    आपका आवेदन तब प्रतीक्षा कर सकता है या Future पर कॉलबैक पंजीकृत कर सकता है ।

  6. उसी पैटर्न का उपयोग ReauthenticateWithProvider के साथ किया जा सकता है जिसका उपयोग हाल ही में लॉगिन की आवश्यकता वाले संवेदनशील संचालन के लिए नए क्रेडेंशियल प्राप्त करने के लिए किया जा सकता है।

    firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);

    आपका आवेदन तब प्रतीक्षा कर सकता है या Future पर कॉलबैक पंजीकृत कर सकता है ।

  7. और, आप विभिन्न पहचान प्रदाताओं को मौजूदा खातों से लिंक करने के लिए LinkWithCredential() उपयोग कर सकते हैं।

    ध्यान दें कि Apple के लिए आवश्यक है कि आप उपयोगकर्ताओं के Apple खातों को अन्य डेटा से लिंक करने से पहले उनकी स्पष्ट सहमति लें।

    उदाहरण के लिए, किसी Facebook खाते को वर्तमान Firebase खाते से लिंक करने के लिए, उस एक्सेस टोकन का उपयोग करें जो आपको उपयोगकर्ता को Facebook में साइन इन करने से मिला है:

    // Initialize a Facebook credential with a Facebook access token.
AuthCredential credential =
    firebase::auth::FacebookAuthProvider.getCredential(token);

// Assuming the current user is an Apple user linking a Facebook provider.
firebase::Future<firebase::auth::AuthResult> result =
    auth.current_user().LinkWithCredential(credential);

एप्पल नोट्स के साथ साइन इन करें

फायरबेस ऑथ द्वारा समर्थित अन्य प्रदाताओं के विपरीत, ऐप्पल फोटो यूआरएल प्रदान नहीं करता है।

साथ ही, जब उपयोगकर्ता अपने ईमेल को ऐप के साथ साझा नहीं करना चुनता है, तो Apple उस उपयोगकर्ता के लिए एक अद्वितीय ईमेल पता प्रदान करता है (फ़ॉर्म xyz@privaterelay.appleid.com ), जिसे वह आपके ऐप के साथ साझा करता है। यदि आपने निजी ईमेल रिले सेवा को कॉन्फ़िगर किया है, तो Apple उपयोगकर्ता के वास्तविक ईमेल पते पर गुमनाम पते पर भेजे गए ईमेल को अग्रेषित करता है।

जब उपयोगकर्ता पहली बार साइन इन करता है, तो Apple केवल ऐप के साथ डिस्प्ले नाम जैसी उपयोगकर्ता जानकारी साझा करता है। आमतौर पर, Firebase उपयोगकर्ता द्वारा पहली बार Apple के साथ साइन इन करने पर डिस्प्ले नाम को स्टोर करता है, जिसे आप current_user().display_name() से प्राप्त कर सकते हैं। हालाँकि, यदि आपने पहले Apple का उपयोग किसी उपयोगकर्ता को ऐप में बिना Firebase के साइन इन करने के लिए किया था, तो Apple उपयोगकर्ता के प्रदर्शन नाम के साथ Firebase प्रदान नहीं करेगा।

अगले कदम

उपयोगकर्ता द्वारा पहली बार साइन इन करने के बाद, एक नया उपयोगकर्ता खाता बनाया जाता है और क्रेडेंशियल्स से लिंक किया जाता है—यानी, उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर, या प्रमाणीकरण प्रदाता जानकारी—जिसके साथ उपयोगकर्ता ने साइन इन किया है। यह नया खाता आपके फायरबेस प्रोजेक्ट के हिस्से के रूप में संग्रहीत है, और उपयोगकर्ता द्वारा साइन इन किए जाने पर ध्यान दिए बिना, आपके प्रोजेक्ट में प्रत्येक ऐप में उपयोगकर्ता की पहचान करने के लिए इसका उपयोग किया जा सकता है।

अपने ऐप्स में, आप उपयोगकर्ता की मूल प्रोफ़ाइल जानकारी firebase::auth::User ऑब्जेक्ट से प्राप्त कर सकते हैं। उपयोगकर्ता प्रबंधित करें देखें।

आपके फायरबेस रीयलटाइम डेटाबेस और क्लाउड स्टोरेज सुरक्षा नियमों में, आप ऑथ चर से साइन-इन किए गए उपयोगकर्ता की विशिष्ट उपयोगकर्ता आईडी प्राप्त कर सकते हैं, और इसका उपयोग यह नियंत्रित करने के लिए कर सकते हैं कि उपयोगकर्ता किस डेटा तक पहुंच सकता है।