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

एक अभ्यास ऐप की जाँच करें

यह क्यों मायने रखता है एक traffic capture एक लंबी, बिखरी सूची है। इसे कुछ काम का बनाने वाला कौशल सादा है: हर field निकालें, फिर उन्हें "किसने पाया" और "यह क्या था" में छाँटें। आप एक अभ्यास fitness ऐप के लिए वह जाँच लिखेंगे, और वही विचार किसी भी request log पर काम करता है जिसे पढ़ने की आपको अनुमति हो।

अभ्यास capture

हमारा अभ्यास ऐप FitFox है, एक बनाया हुआ क़दम गिनने वाला जिसकी अपनी साइट fitfox.example है। उसका capture एक Python सूची है। हर item एक request है, जैसे एक interception proxy उसे log करता:

from watched.leg5b_apps import fitness_app_log

log = fitness_app_log()
print(len(log))      # 12
print(log[3])
# {'t': 3, 'device': 'phone', 'method': 'GET',
#  'url': 'https://sdk.adco.example/ad?idfa=00000000-0000-0000-0000-000000000000&slot=banner&lat=53.80&lon=-1.55',
#  'headers': {}, 'body': {}}

t ऐप खुलने से सेकंड है। headers request headers की एक dict है। body वह डेटा है जो ऐप ने भेजा, पहले से एक dict में decode किया (यह GET requests के लिए ख़ाली है, जो अपना डेटा पते में ले जाती हैं)।

SDK (software development kit): दूसरी कंपनी का code जो एक ऐप में बना है, विज्ञापनों, analytics, नक्शों या crash reports के लिए। एक capture में, एक SDK उस कंपनी के domains की requests के रूप में दिखता है।

तीन जगहें जहाँ डेटा छिपता है

एक ऐप डेटा का एक टुकड़ा तीन जगहों पर रख सकता है, जैसे लिफ़ाफ़े पर लिखना, लिफ़ाफ़े पर एक sticky note पर, या चिट्ठी में:

  1. Query string: URL का ? के बाद का हिस्सा, & से जुड़े name=value जोड़ों के रूप में।
  2. Headers: request पर अतिरिक्त labels, जैसे X-Device-Id: D-7F3A9C।
  3. Body: एक POST request का मुख्य डेटा।

Python की मानक library आपके लिए एक query string बाँटती है। urlsplit एक URL को हिस्सों में तोड़ता है, और parse_qsl query को (name, value) जोड़ों की एक सूची में बदलता है:

from urllib.parse import urlsplit, parse_qsl

parts = urlsplit("https://tiles.mapkit.example/v1/tile?lat=53.80&zoom=14")
print(parts.hostname)          # tiles.mapkit.example
print(parts.query)             # lat=53.80&zoom=14
print(parse_qsl(parts.query))  # [('lat', '53.80'), ('zoom', '14')]

नामों को तुलना लायक बनाना

एक ही विचार एक body में device_id और एक header में X-Device-Id लिखा जा सकता है (X- "custom header" के लिए एक पुरानी आदत है)। तुलना से पहले, हर नाम को normalise करें: lower case, - को _ में बदलें, और शुरू का x_ हटाएँ। अभ्यास दुनिया आपको यह normalise_name के रूप में देती है:

from watched.leg5b_apps import normalise_name
print(normalise_name("X-Device-Id"))   # device_id

मान अलग types में आते हैं (body में 8412 जैसी संख्याएँ हैं)। हर मान को str(value) से एक string में बदलें, ताकि सबकी तुलना एक ही तरह हो।

क्या किस रूप में गिना जाता है

अभ्यास दुनिया आपको normalised नामों के दो sets भी देती है। IDENTIFIER_NAMES में वे नाम हैं जो आपकी या आपके फ़ोन की एक ID ले जाते हैं (device_id, user_id, idfa, email_sha256 वग़ैरह)। LOCATION_NAMES में वे नाम हैं जो बताते हैं कि आप कहाँ हैं (lat, lon, city, postcode वग़ैरह)।

शून्य किया ad ID: जब आप एक iPhone ऐप को कहते हैं कि आपको track न करे, या अपना Android advertising ID हटाते हैं, तो ID माँगने वाले ऐप्स को 00000000-0000-0000-0000-000000000000 मिलता है। वह मान किसी की पहचान नहीं करता, इसलिए वह पहचानकर्ता नहीं गिना जाता। यह ZERO_AD_ID में है। अगला पाठ समझाता है कि यह क्यों दिखता है।

First party है या नहीं

एक request एक SDK की है जब उसका host ऐप की अपनी से एक अलग साइट पर हो। watched का site_of साइट देता है: site_of("cdn.fitfox.example") "fitfox.example" है, और site_of("sdk.adco.example") "adco.example" है।

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

"सिर्फ़ अजीब domains की requests मायने रखती हैं।" FitFox आपकी हृदय गति और ठीक स्थिति अपने server को भेजता है, और एक hashed email partners.fitfox.example को। वह आख़िरी first party दिखता है, पर अकेला नाम आपको नहीं बता सकता कि उसे कौन चलाता है। आपकी जाँच उसे चिह्नित नहीं करेगी; अगला अभ्यास करेगा।

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

JavaScript: URL और URLSearchParams एक URL बाँटते हैं।

function allFields(entry) {
  const norm = n => n.toLowerCase().replaceAll("-", "_").replace(/^x_/, "");
  const out = [];
  for (const [k, v] of new URL(entry.url).searchParams) out.push([norm(k), v]);
  for (const [k, v] of Object.entries(entry.headers)) out.push([norm(k), String(v)]);
  for (const [k, v] of Object.entries(entry.body)) out.push([norm(k), String(v)]);
  return out;
}

Go: net/url वही काम करता है।

u, _ := url.Parse(rawURL)
for name, values := range u.Query() {
    for _, v := range values { fmt.Println(name, v) }
}
fmt.Println(u.Hostname())

सार

  • एक request में डेटा तीन जगहों पर छिपता है: query string, headers और body।
  • urlsplit और parse_qsl एक URL बाँटते हैं; नामों को normalise करना आपको उनकी तुलना करने देता है।
  • एक शून्य किया ad ID किसी की पहचान नहीं करता, इसलिए वह नहीं गिना जाता।
  • साइटों की तुलना ज़्यादातर SDKs ढूँढती है, पर एक first-party दिखने वाला नाम फिर भी कोई और चला सकता है।
आपकी बारी

दो functions लिखें।

  1. all_fields(entry) एक log entry के लिए (name, value) tuples की एक सूची लौटाता है: पहले URL की query string का हर जोड़ा (क्रम में), फिर हर header, फिर हर body item। हर नाम normalise_name से गुज़रता है, और हर मान str() से एक string बनता है। इसे ख़ुद लिखें; अभ्यास दुनिया का fields_of इस्तेमाल न करें।
  2. audit(entries, app_site) तीन keys वाली एक dict लौटाता है, हर एक एक sorted सूची बिना दोहराव के:
    • "sdk_hosts": हर host (urlsplit(url).hostname से) जिसका site_of(host) app_site नहीं है;
    • "identifiers": IDENTIFIER_NAMES में हर field नाम जो एक असली मान के साथ दिखे (ZERO_AD_ID नहीं और ख़ाली नहीं);
    • "location": LOCATION_NAMES में हर field नाम जो दिखे।
आख़िर में, report = audit(fitness_app_log(), "fitfox.example") चलाएँ और उसे print करें।

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

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

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