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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

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

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

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

ऐप्पल के साथ साइन इन कॉन्फ़िगर करें

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

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

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

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

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

इसमें किसी भी प्रत्यक्ष पहचान वाली व्यक्तिगत जानकारी को किसी अनाम 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);
    

Firebase SDK के साथ साइन-इन प्रवाह को प्रबंधित करें

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

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

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

  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 प्रतिक्रिया में अपरिवर्तित कर देगा। फायरबेस मूल गैर को हैश करके और ऐप्पल द्वारा पारित मूल्य से तुलना करके प्रतिक्रिया को मान्य करता है।

  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 की प्रतिक्रिया को संभालें। यदि साइन-इन सफल रहा, तो फायरबेस के साथ प्रमाणित करने के लिए बिना हैश किए गैर के साथ ऐप्पल की प्रतिक्रिया से आईडी टोकन का उपयोग करें:

      - (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::User*> result =
        auth->SignInWithCredential(credential);
    
  5. उसी पैटर्न का उपयोग Reauthenticate के साथ किया जा सकता है जिसका उपयोग संवेदनशील संचालन के लिए नए क्रेडेंशियल्स को पुनः प्राप्त करने के लिए किया जा सकता है जिसके लिए हाल ही में लॉगिन की आवश्यकता होती है।

    firebase::Future<firebase::auth::SignInResult> result =
        user->Reauthenticate(credential);
    
  6. ऐप्पल साइन इन के साथ किसी खाते को जोड़ने के लिए उसी पैटर्न का उपयोग किया जा सकता है। हालाँकि, आपको एक त्रुटि का सामना करना पड़ सकता है जब एक मौजूदा फायरबेस खाता पहले से ही उस ऐप्पल खाते से जुड़ा हुआ हो जिसे आप लिंक करने का प्रयास कर रहे हैं। जब ऐसा होता है तो भविष्य updated_credential की स्थिति लौटाएगा और kAuthErrorCredentialAlreadyInUse के UserInfo ऑब्जेक्ट में एक मान्य SignInResult हो सकता है। इस क्रेडेंशियल का उपयोग Apple से जुड़े खाते में SignInWithCredential के माध्यम से साइन इन करने के लिए किया जा सकता है, बिना किसी अन्य Apple साइन इन टोकन और गैर को उत्पन्न करने की आवश्यकता के बिना।

    ध्यान दें कि आपको क्रेडेंशियल को शामिल करने के लिए इस ऑपरेशन के लिए LinkAndRetrieveDataWithCredential का उपयोग करना चाहिए क्योंकि updated_credential SignInResult.UserInfo ऑब्जेक्ट का सदस्य है।

    firebase::Future<firebase::auth::SignInResult> link_result =
        auth->current_user()->LinkAndRetrieveDataWithCredential(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()->info.updated_credential.is_valid()) {
      // Sign In with the new credential
      firebase::Future<firebase::auth::User*> result = auth->SignInWithCredential(
          link_result.result()->info.updated_credential);
    } else {
      // Another link error occurred.
    }
    

एंड्रॉइड पर

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

Firebase SDK के साथ साइन-इन प्रवाह को प्रबंधित करने के लिए, इन चरणों का पालन करें:

  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::SignInResult> result =
      auth->SignInWithProvider(provider_data);
    

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

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

    firebase::Future<firebase::auth::SignInResult> result =
      user->ReauthenticateWithProvider(provider_data);
    

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

  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::SignInResult> result =
        auth.getCurrentUser().linkWithCredential(credential);
    

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

Firebase Auth द्वारा समर्थित अन्य प्रदाताओं के विपरीत, Apple एक फोटो URL प्रदान नहीं करता है।

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

ऐप्पल केवल उपयोगकर्ता की जानकारी जैसे डिस्प्ले नाम को ऐप के साथ पहली बार साइन इन करता है। आम तौर पर, फायरबेस डिस्प्ले नाम को पहली बार ऐप्पल के साथ साइन इन करता है, जिसे आप getCurrentUser().getDisplayName() के साथ प्राप्त कर सकते हैं। हालांकि, अगर आपने पहले ऐप्पल का इस्तेमाल किसी उपयोगकर्ता को फ़ायरबेस का उपयोग किए बिना ऐप में साइन इन करने के लिए किया था, तो ऐप्पल उपयोगकर्ता के डिस्प्ले नाम के साथ फायरबेस प्रदान नहीं करेगा।

अगले कदम

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

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

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