पाठ्यक्रम 156 में से पाठ 111 · ऐप्स और devices
ऐप्स और devices

SDKs को उनके मालिकों से मिलाएँ

यह क्यों मायने रखता है Hosts कंपनियाँ नहीं हैं। एक कंपनी कई hosts इस्तेमाल कर सकती है, और ऐप का अपना दिखने वाला एक host किसी और का हो सकता है। एक capture को मालिक से समूह बनाना, और हर मालिक को मिला जोड़ना, requests की एक सूची को उस सवाल के जवाब में बदलता है जिसकी आपको असल में परवाह है: किसने मेरे बारे में क्या जाना?

पते और मकान-मालिक

एक host नाम एक सड़क के पते जैसा है; मालिक मकान-मालिक है। events.metrics.example और cdn.metrics.example एक ही मकान-मालिक वाले दो पते हैं। और partners.fitfox.example FitFox की सड़क पर है, फिर भी एक अलग मकान-मालिक (AdCo) उसे किराए पर लेता है। यह चरण 1 में मिले CNAME cloaking का ऐप वर्ज़न है।

Domain map: एक सूची जो बताती है कि कौन-सी कंपनी कौन-सा host या साइट चलाती है। असली वाले शोधकर्ता और tracker-रोकने वाले प्रोजेक्ट बनाते हैं; हमारा SDK_OWNERS है, अभ्यास दुनिया में एक सादी dict।

from watched.leg5b_apps import SDK_OWNERS
print(SDK_OWNERS["adco.example"])            # AdCo
print(SDK_OWNERS["partners.fitfox.example"]) # AdCo
print(SDK_OWNERS["fitfox.example"])          # FitFox

सबसे विशिष्ट पहले

a.b.adco.example का मालिक ढूँढने के लिए, पूरा नाम आज़माएँ, फिर सबसे बाईं ओर का label (एक label बिंदु से अलग एक टुकड़ा है) हटाकर फिर आज़माएँ: b.adco.example, फिर adco.example। पहले मेल पर रुकें। example जैसे एक अकेले label तक पहुँचने से पहले रुकें, जिसका कोई मालिक नहीं। अगर कुछ मेल न खाए, तो मालिक "Unknown" है, और एक अनजान मालिक कम नहीं, ज़्यादा ध्यान के लायक है।

labels = "a.b.adco.example".split(".")   # ['a', 'b', 'adco', 'example']
print(".".join(labels[1:]))              # b.adco.example

सबसे विशिष्ट पहले जाना ही partners.fitfox.example को पकड़ता है: उसका पूरा नाम map में AdCo के रूप में है, इसलिए आप कभी FitFox पर वापस नहीं गिरते।

एक डेटा-साझा graph

डेटा-साझा graph: हर कंपनी से उसे मिले डेटा की तरहों तक एक नक्शा। यहाँ हम इसे एक dict के रूप में रखते हैं, मालिक -> तरहों की sorted सूची।

अभ्यास दुनिया आपको fields_of(entry) (पिछले पाठ के आपके all_fields जैसा ही) और DATA_KINDS देती है, जो बताती है कि एक field नाम किस तरह का डेटा ले जाता है:

from watched.leg5b_apps import DATA_KINDS
print(DATA_KINDS["heart_rate"])   # health
print(DATA_KINDS.get("slot"))     # None (not personal, ignore it)

तरहें identifier, location, health, contact और viewing हैं। पहले की तरह, एक identifier field जिसका मान ZERO_AD_ID (या ख़ाली) हो नहीं गिना जाता। ऐप ने जिस भी मालिक से संपर्क किया वह graph में दिखता है, एक ख़ाली सूची के साथ भी, क्योंकि अकेला एक connection आपका IP address और समय सौंप देता है।

एक अंक जिसकी आप तुलना कर सकें

एक अकेली संख्या आपको एक नज़र में दो ऐप्स की तुलना करने देती है। हमारी जानबूझकर सादी है: ऐप की अपनी कंपनी के अलावा हर मालिक के लिए, संपर्क का 1 जोड़ें, साथ में उसे मिली हर तरह के लिए KIND_WEIGHTS से एक भार (identifier 2, location 3, health 3, contact 3, viewing 2)। FitFox का अंक 26 है।

असली शोधकर्ता चीज़ों को अलग तौलते हैं, और कोई अंक सब कुछ नहीं पकड़ता। एक अंक बातचीत शुरू करने वाला है: यह "यह ऐप उससे दोगुना साझा करता है" के लिए एक फ़ैसले से ज़्यादा काम का है।

एक आम ग़लतफ़हमी

"ज़्यादा hosts का मतलब ज़्यादा साझा करना।" एक ऐप दस hosts इस्तेमाल कर सकता है जो सब वह ख़ुद चलाता है और एक host जो एक data broker चलाता है। मालिकों को, और उन्हें क्या मिला, गिनना hosts गिनने से सच के ज़्यादा क़रीब है।

दूसरी भाषाओं में

JavaScript (उदाहरण)

function ownerOf(host, owners) {
  const labels = host.toLowerCase().split(".");
  for (let i = 0; i < labels.length - 1; i++) {
    const name = labels.slice(i).join(".");
    if (name in owners) return owners[name];
  }
  return "Unknown";
}

Rust (उदाहरण)

fn owner_of(host: &str, owners: &HashMap<&str, &str>) -> String {
    let labels: Vec<&str> = host.split('.').collect();
    for i in 0..labels.len().saturating_sub(1) {
        if let Some(o) = owners.get(labels[i..].join(".").as_str()) {
            return o.to_string();
        }
    }
    "Unknown".to_string()
}

सार

  • host से नहीं, मालिक से समूह बनाएँ: एक कंपनी के कई hosts हैं, और एक जाना-पहचाना दिखने वाला host किसी और का हो सकता है।
  • पहले सबसे विशिष्ट नाम खोजें, फिर labels एक-एक कर हटाएँ; कोई मेल नहीं का मतलब "Unknown"।
  • एक डेटा-साझा graph हर मालिक के लिए उसे मिले डेटा की तरहें सूचीबद्ध करता है।
  • एक सादा अंक ऐप्स की तुलना में मदद करता है, पर यह एक शुरुआत है, एक फ़ैसला नहीं।
आपकी बारी

तीन functions लिखें।

  1. owner_of(host, owners): dict owners में host खोजें; अगर वह नहीं है, तो सबसे बाईं ओर का label हटाकर फिर आज़माएँ, एक अकेला label बचने से पहले रुकते हुए। मिला पहला मालिक लौटाएँ, या "Unknown"।
  2. sharing_graph(entries, owners): एक dict लौटाएँ जो संपर्क किए हर मालिक (urlsplit(url).hostname से host इस्तेमाल करें) को उसे मिले डेटा की तरहों की एक sorted सूची बिना दोहराव के से जोड़े। fields_of और DATA_KINDS इस्तेमाल करें; DATA_KINDS में न होने वाले नाम छोड़ें, और वे identifier fields छोड़ें जिनका मान ZERO_AD_ID या ख़ाली हो। जिन मालिकों को कुछ निजी नहीं मिला वे भी [] के साथ दिखते हैं।
  3. sharing_score(graph, app_owner): app_owner के अलावा हर मालिक के लिए, 1 और उसकी हर तरह के लिए KIND_WEIGHTS[kind] जोड़ें। कुल लौटाएँ।
फिर graph = sharing_graph(fitness_app_log(), SDK_OWNERS), score = sharing_score(graph, "FitFox") सेट करें, और दोनों print करें।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।