विज्ञापन नेटवर्क के लिए, विज्ञापन देने वाले के आइडेंटिफ़ायर को डिक्रिप्ट करना

का उपयोग करने वाले विज्ञापन नेटवर्क Authorized Buyers की मदद से विज्ञापन दिखाने वाले JavaScript टैग को अनुमति दी जा सकती है Android और iOS, दोनों डिवाइसों के लिए विज्ञापन देने वाले के आइडेंटिफ़ायर देख सकते हैं. जानकारी %%EXTRA_TAG_DATA%% के ज़रिए भेजी जाती है या JavaScript टैग में %%ADVERTISING_IDENTIFIER%% मैक्रो को मैनेज किया जा रहा है Authorized Buyers की ओर से. इस सेक्शन के बाकी हिस्से का फ़ोकस, %%EXTRA_TAG_DATA%% लेकिन देखें ज़्यादा जानकारी के लिए, IDFA या विज्ञापन आईडी के साथ रीमार्केटिंग %%ADVERTISING_IDENTIFIER%% एन्क्रिप्ट किए गए प्रोटो बफ़र पर MobileAdvertisingId को ज़रूरत के हिसाब से डिक्रिप्ट किया जा सकता है.

टाइमलाइन

1. विज्ञापन नेटवर्क कंपनी अपने JavaScript इन-ऐप्लिकेशन टैग को अपडेट करती है Authorized Buyers के यूज़र इंटरफ़ेस (यूआई) के ज़रिए, जैसा कि नीचे बताया गया है, %%EXTRA_TAG_DATA%% मैक्रो में जोड़ना होगा.
2. ऐप्लिकेशन, Authorized Buyers से विज्ञापन दिखाने के लिए Google Mobile Ads SDK और विज्ञापन देने वाले का आइडेंटिफ़ायर सुरक्षित तरीके से पास किया जा सकता है.
3. ऐप्लिकेशन को %%EXTRA_TAG_DATA%% के साथ JavaScript टैग वापस मिलता है मैक्रो में एन्क्रिप्ट (सुरक्षित) किया गया विज्ञापन नेटवर्क प्रोटोकॉल बफ़र, जिसमें वह आइडेंटिफ़ायर मौजूद है.
4. ऐप्लिकेशन इस टैग को चलाता है और जीतने के लिए विज्ञापन नेटवर्क को कॉल करता है विज्ञापन
5. इस जानकारी का इस्तेमाल करने के लिए (कमाई करने) के लिए, विज्ञापन नेटवर्क को प्रोसेस करना ज़रूरी है प्रोटोकॉल बफ़र:
   1. WebSafeBase64 की मदद से Websafe स्ट्रिंग को वापस बाइटस्ट्रिंग में डिकोड करें.
   2. नीचे बताई गई स्कीम का इस्तेमाल करके, इसे डिक्रिप्ट करें.
   3. प्रोटो को डीसीरियलाइज़ (पार्स) करना और विज्ञापन देने वाले का आईडी हासिल करना ExtraTagData.advertising_id या ExtraTagData.hashed_idfa.

डिपेंडेंसी

1. WebSafeBase64 एन्कोडर.
2. ऐसी क्रिप्टो लाइब्रेरी जो SHA-1 एचएमएसी के साथ काम करती है, जैसे कि Openssl.
3. Google प्रोटोकॉल बफ़र कंपाइलर.

वेबसुरक्षित स्ट्रिंग डिकोड करें

क्योंकि %%EXTRA_TAG_DATA%% मैक्रो के ज़रिए जानकारी भेजी गई थी को यूआरएल की मदद से भेजा जाना चाहिए, Google के सर्वर इसे वेब-सुरक्षित base64 (RFC 3548) की मदद से कोड में बदलते हैं.

कोशिश करने से पहले इसलिए, आपको ASCII वर्णों को बाइट स्ट्रिंग. नीचे दिया गया C++ कोड का नमूना OpenSSL पर आधारित है प्रोजेक्ट का BIO_f_base64() और Google के सैंपल का हिस्सा है डिक्रिप्शन कोड.

string AddPadding(const string& b64_string) {
  if (b64_string.size() % 4 == 3) {
    return b64_string + "=";
  } else if (b64_string.size() % 4 == 2) {
    return b64_string + "==";
  }
  return b64_string;
}

// Adapted from http://www.openssl.org/docs/man1.1.0/crypto/BIO_f_base64.html
// Takes a web safe base64 encoded string (RFC 3548) and decodes it.
// Normally, web safe base64 strings have padding '=' replaced with '.',
// but we will not pad the ciphertext. We add padding here because
// openssl has trouble with unpadded strings.
string B64Decode(const string& encoded) {
  string padded = AddPadding(encoded);
  // convert from web safe -> normal base64.
  int32 index = -1;
  while ((index = padded.find_first_of('-', index + 1)) != string::npos) {
    padded[index] = '+';
  }
  index = -1;
  while ((index = padded.find_first_of('_', index + 1)) != string::npos) {
    padded[index] = '/';
  }

  // base64 decode using openssl library.
  const int32 kOutputBufferSize = 256;
  char output[kOutputBufferSize];

  BIO* b64 = BIO_new(BIO_f_base64());
  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
  BIO* bio = BIO_new_mem_buf(const_cast<char*>(padded.data()),
                             padded.length());
  bio = BIO_push(b64, bio);
  int32 out_length = BIO_read(bio, output, kOutputBufferSize);
  BIO_free_all(bio);
  return string(output, out_length);
}

एन्क्रिप्ट की गई बाइटस्ट्रिंग का स्ट्रक्चर

ASCII वर्णों को वापस बाइटस्ट्रिंग में डिकोड करने के बाद, आप तैयार हैं ताकि आप उसे डिक्रिप्ट कर सकें. एन्क्रिप्ट (सुरक्षित) की गई बाइटस्ट्रिंग में तीन सेक्शन होते हैं:

• initialization_vector: 16-बाइट.
• ciphertext: 20-बाइट वाले सेक्शन की सीरीज़.
• integrity_signature: 4-बाइट.

{initialization_vector (16 bytes)}{ciphertext (20-byte sections)}{integrity_signature (4 bytes)}

ciphertext बाइट वाले अरे को कई 20-बाइट में बांटा गया है सेक्शन, जिसमें सबसे आखिरी सेक्शन के बीच का अंतर हो सकता है 1 और 20 बाइट के साथ. मूल दस्तावेज़ के हर सेक्शन के लिए byte_array, संबंधित 20-बाइट ciphertext जनरेट किया गया है:

<byte_array <xor> HMAC(encryption_key, initialization_vector || counter_bytes)>

जहां || को जोड़ा जा रहा है.

परिभाषाएं

वैरिएबल	ब्यौरा
initialization_vector	16 बाइट - इंप्रेशन के लिए यूनीक होते हैं.
encryption_key	32 बाइट - खाता सेटअप करते समय दी जाती है.
integrity_key	32 बाइट - खाता सेटअप करते समय दी जाती है.
byte_array	20-बाइट वाले सेक्शन में, क्रम से लगाया गया ExtraTagData ऑब्जेक्ट.
counter_bytes	बाइट वैल्यू, सेक्शन की ऑर्डिनल संख्या दिखाती है. इसकी जानकारी नीचे दी गई है.
final_message	%%EXTRA_TAG_DATA%% मैक्रो से भेजा गया कुल बाइट अरे (इसमें WebSafeBase64 एन्कोडिंग शामिल नहीं है).

ऑपरेटर	ब्यौरा
hmac(key, data)	data को एन्क्रिप्ट (सुरक्षित) करने के लिए, key का इस्तेमाल करके SHA-1 एचएमएसी.
a || b	स्ट्रिंग a को b स्ट्रिंग से जोड़ा गया है.

काउंटर_बाइट की गणना करना

counter_bytes ciphertext. ध्यान दें कि आख़िरी सेक्शन में 20 बाइट के साथ. counter_bytes को सही वैल्यू से भरने के लिए hmac() फ़ंक्शन चलाते समय 20 बाइट वाले सेक्शन गिनें (बाकी सहित) और नीचे दी गई रेफ़रंस टेबल का इस्तेमाल करें:

सेक्शन नंबर	counter_bytes की कीमत का
0	कोई नहीं
1 ... 256	1 बाइट. वैल्यू एक क्रम में 0 से 255 तक बढ़ती है.
257 ... 512	2 बाइट. पहले बाइट की वैल्यू 0 है, यानी दूसरे बाइट की वैल्यू क्रम में, 0 से 255 तक की बढ़ोतरी.
513 ... 768	3 बाइट. पहले दो बाइट की वैल्यू 0 है, यानी कि आखिरी बाइट की वैल्यू क्रम में, 0 से 255 तक की बढ़ोतरी.

वापस सबसे ऊपर जाएं

एन्क्रिप्शन स्कीम

एन्क्रिप्शन स्कीम उसी स्कीम पर आधारित होती है, जिसका इस्तेमाल एन्क्रिप्ट करने के लिए हाइपरलोकल टारगेटिंग सिग्नल.

1. क्रम से लगाना: ExtraTagData ऑब्जेक्ट का एक ऐसा इंस्टेंस जो प्रोटोकॉल बफ़र में परिभाषित किया गया है और उसे पहले इसके माध्यम से क्रम में लगाया गया है SerializeAsString() से एक बाइट अरे के लिए.

2. एन्क्रिप्ट (सुरक्षित) करने का तरीका: इसके बाद, बाइट अरे को यह पक्का करते हुए कि कस्टम एन्क्रिप्शन स्कीम, ओवरहेड को कम करने के लिए डिज़ाइन की गई है की ज़रूरत नहीं है. एन्क्रिप्ट (सुरक्षित) करने की स्कीम, पासकोड वाले एचएमएसी एल्गोरिदम का इस्तेमाल करके जनरेट करती है initialization_vector पर आधारित सीक्रेट पैड, जो इतना खास है: इंप्रेशन इवेंट को ध्यान में रखकर बनाया गया है.

एन्क्रिप्शन pseudocode

byte_array = SerializeAsString(ExtraTagData object)
pad = hmac(encryption_key, initialization_vector ||
      counter_bytes )  // for each 20-byte section of byte_array
ciphertext = pad <xor> byte_array // for each 20-byte section of byte_array
integrity_signature = hmac(integrity_key, byte_array ||
                      initialization_vector)  // first 4 bytes
final_message = initialization_vector || ciphertext || integrity_signature

डिक्रिप्शन स्कीम

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

1. अपना पैड जनरेट करें: HMAC(encryption_key, initialization_vector || counter_bytes)
2. XOR: इस नतीजे और <xor> को एन्क्रिप्शन को रिवर्स करने के लिए साइफ़रटेक्स्ट.
3. पुष्टि करें: इंटिग्रिटी सिग्नेचर, HMAC(integrity_key, byte_array || initialization_vector)

डिक्रिप्शन स्यूडोकोड

// split up according to length rules
(initialization_vector, ciphertext, integrity_signature) = final_message

// for each 20-byte section of ciphertext
pad = hmac(encryption_key, initialization_vector || counter_bytes)

// for each 20-byte section of ciphertext
byte_array = ciphertext <xor> pad

confirmation_signature = hmac(integrity_key, byte_array ||
                         initialization_vector)
success = (confirmation_signature == integrity_signature)

C++ कोड का नमूना

यहां मुख्य फ़ंक्शन के बारे में बताया गया है. डिक्रिप्शन उदाहरण के तौर पर दिया गया कोड.

bool DecryptByteArray(
    const string& ciphertext, const string& encryption_key,
    const string& integrity_key, string* cleartext) {
  // Step 1. find the length of initialization vector and clear text.
  const int cleartext_length =
     ciphertext.size() - kInitializationVectorSize - kSignatureSize;
  if (cleartext_length < 0) {
    // The length cannot be correct.
    return false;
  }

  string iv(ciphertext, 0, kInitializationVectorSize);

  // Step 2. recover clear text
  cleartext->resize(cleartext_length, '\0');
  const char* ciphertext_begin = string_as_array(ciphertext) + iv.size();
  const char* const ciphertext_end = ciphertext_begin + cleartext->size();
  string::iterator cleartext_begin = cleartext->begin();

  bool add_iv_counter_byte = true;
  while (ciphertext_begin < ciphertext_end) {
    uint32 pad_size = kHashOutputSize;
    uchar encryption_pad[kHashOutputSize];

    if (!HMAC(EVP_sha1(), string_as_array(encryption_key),
              encryption_key.length(), (uchar*)string_as_array(iv),
              iv.size(), encryption_pad, &pad_size)) {
      printf("Error: encryption HMAC failed.\n");
      return false;
    }

    for (int i = 0;
         i < kBlockSize && ciphertext_begin < ciphertext_end;
         ++i, ++cleartext_begin, ++ciphertext_begin) {
      *cleartext_begin = *ciphertext_begin ^ encryption_pad[i];
    }

    if (!add_iv_counter_byte) {
      char& last_byte = *iv.rbegin();
      ++last_byte;
      if (last_byte == '\0') {
        add_iv_counter_byte = true;
      }
    }

    if (add_iv_counter_byte) {
      add_iv_counter_byte = false;
      iv.push_back('\0');
    }
  }

विज्ञापन नेटवर्क प्रोटोकॉल बफ़र से डेटा पाना

इसमें पास किए गए डेटा को डिकोड और डिक्रिप्ट करने के बाद %%EXTRA_TAG_DATA%%, आप प्रोटोकॉल बफ़र को डीसीरियलाइज़ (पार्स) करने के लिए तैयार हैं और टारगेटिंग के लिए, विज्ञापन देने वाले का आइडेंटिफ़ायर पाएं.

अगर आपको प्रोटोकॉल बफ़र के बारे में पता नहीं है, तो हमारे दस्तावेज़ पढ़ें.

परिभाषा

हमारे विज्ञापन नेटवर्क प्रोटोकॉल का बफ़र, इस तरह से तय किया जाता है:

message ExtraTagData {
  // advertising_id can be Apple's identifier for advertising (IDFA)
  // or Android's advertising identifier. When the advertising_id is an IDFA,
  // it is the plaintext returned by iOS's [ASIdentifierManager
  // advertisingIdentifier]. For hashed_idfa, the plaintext is the MD5 hash of
  // the IDFA.  Only one of the two fields will be available, depending on the
  // version of the SDK making the request.  Later SDKs provide unhashed values.
  optional bytes advertising_id = 1;
  optional bytes hashed_idfa = 2;
}

आपको ParseFromString() का इस्तेमाल करके, इसे डीसीरियलाइज़ करना होगा. इसका तरीका C++ प्रोटोकॉल बफ़र का दस्तावेज़.

Android advertising_id और iOS के बारे में जानकारी के लिए hashed_idfa फ़ील्ड, डिक्रिप्ट करें देखें विज्ञापन आईडी और टारगेटिंग मोबाइल ऐप्लिकेशन IDFA वाली इन्वेंट्री होनी चाहिए.

Java लाइब्रेरी

कोड में बदलने और डिकोड करने के लिए, क्रिप्टो एल्गोरिदम लागू करने के बजाय आइडेंटिफ़ायर के लिए, विज्ञापन नेटवर्क कंपनी के आइडेंटिफ़ायर का इस्तेमाल करें, DoubleClickCrypto.java. ज़्यादा जानकारी के लिए, यह देखें क्रिप्टोग्राफ़ी.