सेवा देने वाली कंपनी का विज्ञापन सिग्नल

विज्ञापन: खोजे जाने लायक होने पर

जब डिवाइस को BR/EDR मोड में जोड़ा जा सकता है, तो वह BLE के ज़रिए फ़ास्ट पेयर मॉडल आईडी डेटा का विज्ञापन करेगा. साथ ही, BLE पता नहीं बदलेगा.

विज्ञापन के बीच का अंतराल: जब खोजा जा सकता है

विज्ञापनों के बीच का इंटरवल 100 मिलीसेकंड (10 हर्ट्ज़) से ज़्यादा नहीं होना चाहिए. तेज़ दर से स्कैन करने पर, खोजने वाला व्यक्ति, कम बैटरी मोड में स्कैन करने के बावजूद, प्रोवाइडर को तुरंत ढूंढ सकता है.

विज्ञापन पेलोड: फ़ास्ट पेयर मॉडल आईडी का डेटा

विज्ञापन में सेवा डेटा का डेटा टाइप शामिल होना चाहिए, § 1.11. यूयूआईडी, 0xFE2C की फ़ास्ट पेयर सेवा का यूयूआईडी होना चाहिए. सेवा के डेटा में ये चीज़ें शामिल होंगी:

ऑक्टेट	डेटा टाइप	ब्यौरा	मान
0-2	uint24	24-बिट मॉडल आईडी	अलग-अलग होता है

विज्ञापन: जब खोजे न जा सकने की सेटिंग चालू हो

जब डिवाइस को ढूंढा नहीं जा सकता (यानी, वह जोड़ने के मोड में नहीं है), तो डिवाइस की सेवा देने वाली कंपनी का डिवाइस, यहां दिए गए दिशा-निर्देशों का इस्तेमाल करके, फ़ास्ट पेयर खाते के डेटा का विज्ञापन करेगा.

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

विज्ञापन के बीच का अंतराल: जब विज्ञापन खोजे न जा सकें

विज्ञापनों के बीच का अंतराल ज़्यादा से ज़्यादा 250 मिलीसेकंड (4 हर्ट्ज़) होना चाहिए.

विज्ञापन पेलोड: फ़ास्ट पेयर खाते का डेटा

विज्ञापन में सेवा डेटा का डेटा टाइप शामिल होना चाहिए, Ibid., § 1.11. यूयूआईडी, 0xFE2C की फ़ास्ट पेयर सेवा का यूयूआईडी होना चाहिए. सेवा के डेटा में ये चीज़ें शामिल होंगी:

ऑक्टेट	डेटा टाइप	ब्यौरा	मान
0	uint8	वर्शन और फ़्लैग 0bVVVVFFFF V = वर्शन F = फ़्लैग	0x00 (आने वाले समय में इस्तेमाल के लिए रिज़र्व किया गया)
1 - अलग-अलग		खाता कुंजी का डेटा	अलग-अलग

खाता कुंजी के डेटा में ये शामिल हैं:

ऑक्टेट	डेटा टाइप	ब्यौरा	मान
0	uint8	फ़ील्ड की लंबाई और टाइप 0bLLLLTTTT L = खाता कुंजी फ़िल्टर की लंबाई, बाइट में T = टाइप	0bLLLL0000 length = 0bLLLL = अलग-अलग type = 0b0000 (यूज़र इंटरफ़ेस (यूआई) का संकेत दिखाएं) या 0b0010 (यूज़र इंटरफ़ेस (यूआई) का संकेत छिपाएं), खाता कुंजी फ़िल्टर
1 - s		खाता कुंजी फ़िल्टर	अलग-अलग होता है
s + 1	uint8	फ़ील्ड की लंबाई और टाइप 0bLLLLTTTT L = बाइट में लंबाई T = टाइप	0b00100001 लंबाई = 0b0010 = 2 type = 0b0001, Salt
s + 2 - s + 3	uint16	Salt	अलग-अलग होता है

खाता कुंजी फ़िल्टर

विज्ञापन में दिखाए गए खाता कुंजी फ़िल्टर की मदद से, सेवा खोजने वाला व्यक्ति तुरंत यह पता लगा सकता है कि सेवा देने वाली कंपनी के पास कोई खाता कुंजी है या नहीं. साथ ही, यह भी पता लगाया जा सकता है कि क्या सेवा देने वाली कंपनी के पास, सेवा खोजने वाले व्यक्ति के खाते की जानकारी है. हालांकि, इसकी संभावना बहुत कम होती है. अगर Seeker को टाइप 0 के साथ कोई फ़िल्टर ब्रॉडकास्ट करते हुए दिखता है, तो वह अपने-आप कनेक्ट हो सकता है और प्रोसेस शुरू करने की कोशिश कर सकता है.इसका मतलब है कि यूज़र इंटरफ़ेस (यूआई) का ऐसा संकेत दिख रहा है जिसमें उसकी खाता कुंजी शामिल हो सकती है. ऐसा इसलिए किया जाता है, ताकि गलत पहचान की दर को और कम किया जा सके. कुछ मामलों में, हो सकता है कि डिवाइस जोड़ने के लिए तैयार न होने पर भी, डिवाइस देने वाला व्यक्ति, डिवाइस पाने वाले व्यक्ति को अपनी पहचान बताना चाहे. उदाहरण के लिए, जब बड को फिर से केस में डाला जाता है, तो हम बाद में पेयर करने की सूचना दिखाना बंद कर देते हैं. ऐसा इसलिए, क्योंकि हेडसेट उस पेयरिंग को अस्वीकार कर सकता है.

खाता कुंजी फ़िल्टर, वैरिएबल-लेंथ वाला ब्लूम फ़िल्टर होता है. इसे इस तरह से बनाया जाता है:

1. मान लें कि n, सेव की गई खाता कुंजी की सूची में मौजूद खाता कुंजियों की संख्या है (n >= 1).
2. मान लें कि s, बाइट में फ़िल्टर का साइज़ है, जो (1.2*n + 3) ट्रिंकेट किया गया है. उदाहरण के लिए, अगर एक कुंजी को सेव किया जाता है, तो s = 4 बाइट.
   uint8_t s = (((uint8_t)(( float )1.2 * n)) + 3);
3. फ़िल्टर F को s बाइट के ऐरे के तौर पर शुरू करें. हर बाइट को 0 पर सेट करें.
   uint8_t F[s] = {0};

4. सेव की गई खाता कुंजी की सूची में मौजूद हर खाता कुंजी K के लिए:
   a. मान लें कि V, concat(K, Salt) है.
   

   // In the sample code, the size of salt is 2 bytes.
   #define SALT_SIZE 2
   
   uint8_t V[FASTPAIR_ACCOUNT_KEY_SIZE + SALT_SIZE];
   for (uint8_t keyIndex = 0; keyIndex < n; keyIndex++)
     {
        // concat (K, Salt)
         fastpair_get_account_key_by_index(keyIndex, V);
   
         uint8_t randomSalt = (uint8_t)rand();
         V[FASTPAIR_ACCOUNT_KEY_SIZE] = randomSalt;
         ... }
   

   b. SHA256 का इस्तेमाल करके V को हैश करें. इससे 32-बाइट की वैल्यू H = {H₀, …, H₃₁} मिलती है.

   uint8_t H[32] = {0};
   SHA256_hash_function(V, H);
   

   c. H को बिग-एंडियन में, आठ चार-बाइट के बिना साइन वाले पूर्णांकों में बांटें, X = {X₀, …, X₇}, जहां X₀ = 0xH₀H₁H₂H₃.

        uint32_t X[8];
        for (index = 0; index < 8; index++)
        {
           X[index] = (((uint32_t)(H[index * 4])) << 24) |
                       (((uint32_t)(H[index * 4 + 1])) << 16) |
                       (((uint32_t)(H[index * 4 + 2])) << 8) |
                       (((uint32_t)(H[index * 4 + 3])) << 0);
        }
   

   d. हर X_i के लिए:
   i. मान लें कि M, फ़िल्टर में बिट की संख्या, (s * 8) के मॉड्यूलो के साथ X_i है.
   ii. इंडेक्स (M / 8) पर F में बाइट को राउंड-डाउन करें.
   iii. बाइट में, इंडेक्स (M % 8) पर बिट को 1 पर सेट करें.
   iv. दूसरे शब्दों में:
   

       // M = Xi % (s * 8)
       // F[M/8] = F[M/8] | (1 << (M % 8))
       for (index = 0; index < 8; index++)
       {
           uint32_t M    = X[index] % (s * 8);
           F[M / 8] = F[M / 8] | (1 << (M % 8));
       }
   

विज्ञापन डेटा में, खाता कुंजी फ़िल्टर फ़ील्ड के तौर पर फ़िल्टर F शामिल करें. ध्यान दें कि इस वैल्यू में "endianness" नहीं है, क्योंकि इसमें कोई ज़्यादा या कम अहम बाइट नहीं है—बाइट के क्रम में बदलाव न करें.

नमक का खेत

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

साल्ट का इस्तेमाल करके खाता कुंजी फ़िल्टर जनरेट करने के लिए:

1. दो बाइट का कोई रैंडम S जनरेट करें. ध्यान दें कि इस वैल्यू में "endianness" नहीं है, क्योंकि इसमें कोई ज़्यादा या कम अहम बाइट नहीं है — बाइट के क्रम में बदलाव न करें.
2. साल्ट के तौर पर, दो बाइट वाले S का इस्तेमाल करें.
3. विज्ञापन में दिखाए गए फ़ास्ट पेयर खाते के डेटा में, जनरेट किया गया फ़िल्टर, खाता कुंजी फ़िल्टर फ़ील्ड में और S को साल्ट फ़ील्ड में शामिल करें.