पाठ्यक्रम 156 में से पाठ 114 · एक ब्राउज़र कैसे तय करता है
एक ब्राउज़र कैसे तय करता है

साइटें, origins और "एक ही साइट"

यह क्यों मायने रखता है एक ब्राउज़र के अंदर हर निजता नियम एक सवाल से शुरू होता है: "यह कौन-सी साइट है?" Cookies, partitions, SameSite, tracker सूचियाँ और bounce पहचान सब चीज़ें एक साइट के नीचे दर्ज करते हैं। अगर एक engine यह जवाब ग़लत दे, तो एक tracker दो jars के बीच फिसल सकता है, या दो अजनबियों के blogs एक ही साझा कर सकते हैं। इस पाठ में आप यह जवाब ख़ुद लिखते हैं।

फ़्लैटों की एक इमारत की सोचें। सड़क का पता (example) सबका साझा है, इसलिए वह आपको कुछ नहीं बताता कि कौन कहाँ रहता है। फ़्लैट नंबर और सड़क (shopa.example) एक घर है। फ़्लैट के अंदर के कमरे (cdn.shopa.example, www.shopa.example) सब उसी घर के हैं। एक ब्राउज़र घर चाहता है।

तीन शब्द जो आपको चाहिए

Host: एक URL का नाम वाला हिस्सा, जैसे https://cdn.shopa.example:8443/lib.js में cdn.shopa.example। यह बिंदुओं से अलग labels से बना है: cdn, shopa, example।

Origin: scheme, host और port साथ में, जैसे https://cdn.shopa.example:8443। यह सबसे सख़्त सीमा है: https://www.shopa.example और https://shopa.example अलग origins हैं।

Site: host का वह हिस्सा जो एक मालिक ने register किया, जिसे registrable domain भी कहते हैं: ऊपर के सारे hosts के लिए shopa.example। Partitioning और SameSite जैसे निजता features साइटों पर काम करते हैं, क्योंकि एक मालिक वैसे भी उसके नीचे हर host नियंत्रित करता है।

Public suffix list

"आख़िरी दो labels लें" shopa.example के लिए काम करता है, पर practice-shop.co.uk के लिए विफल होता है: आख़िरी दो labels co.uk हैं, जिसे हज़ारों असंबंधित कंपनियाँ साझा करती हैं। इसलिए ब्राउज़र एक public suffix list रखते हैं, उन endings की एक लंबी फ़ाइल जिनके नीचे कोई भी एक नाम register कर सकता है।

Public suffix: एक ending जिसका कोई पूरे तौर पर मालिक नहीं, जैसे com, co.uk या github.io। साइट public suffix और उसके बाईं ओर एक और label है।

सूची में hosting services के जोड़े "private" suffixes भी हैं। github.io उस पर है, इसलिए alice.github.io और bob.github.io दो अलग साइटें हैं, भले ही एक कंपनी servers चलाती है। उस entry के बिना, Alice का blog एक cookie सेट कर सकता था जो Bob के blog को मिलती। हमारी अभ्यास दुनिया में, pages.example वही भूमिका निभाता है।

नियम, जैसे ब्राउज़र उन्हें लागू करता है:

  1. host को lower-case करें, port हटाएँ, और आख़िरी बिंदु हटाएँ (shopa.example. shopa.example लिखने का एक वैध तरीका है)।
  2. host की वह सबसे लंबी ending ढूँढें जो सूची पर है। a.b.practice-charity.org.uk के लिए, uk और org.uk दोनों सूची में हैं; org.uk जीतता है।
  3. साइट वह ending और उसके बाईं ओर एक label है।
  4. अगर host ख़ुद एक public suffix है (जैसे सादा github.io), तो साइट host ही है।
  5. अगर कोई सूचीबद्ध ending बिल्कुल मेल न खाए, तो आख़िरी label को suffix मानें। इसलिए dev.app.zz की साइट app.zz है।

असली सूचियों में कुछ wildcard और exception नियम भी हैं, और एक IP address अपनी साइट है। Engines उन्हें भी संभालते हैं; आप उन्हें यहाँ छोड़ सकते हैं।

Schemeful same-site

पुराने ब्राउज़र सिर्फ़ registrable domain की तुलना करते थे, इसलिए http://shopa.example और https://shopa.example "एक ही साइट" थे। आज के web मानक same-site को schemeful परिभाषित करते हैं: scheme साइट का हिस्सा है, इसलिए सादा-http पन्ना एक अलग, अविश्वसनीय साइट गिना जाता है। यह इसलिए मायने रखता है कि आपके café Wi-Fi पर कोई भी एक http पन्ने से छेड़छाड़ कर सकता है, और उसे https साइट की SameSite cookies उधार नहीं लेनी चाहिए।

ABएक ही origin?एक ही साइट?
https://www.shopa.examplehttps://shopa.exampleनहींहाँ
https://alice.github.iohttps://bob.github.ioनहींनहीं
http://shopa.examplehttps://shopa.exampleनहींनहीं (schemeful)
https://shopa.example:8443https://shopa.exampleनहींहाँ (ports नहीं गिने जाते)

आपको चाहिए Python

Variables, if, lists और functions के अलावा, आपको चार छोटे औज़ार चाहिए। हर एक यहाँ उसके साथ दिखाया गया है जो वह print करता है।

from urllib.parse import urlsplit       # part of Python's standard library

parts = urlsplit("https://CDN.ShopA.example:8443/lib.js")
print(parts.scheme)      # https
print(parts.hostname)    # cdn.shopa.example   (already lower case, port removed)

labels = "cdn.shopa.example".split(".")   # cut a string at every dot
print(labels)            # ['cdn', 'shopa', 'example']
print(labels[1:])        # ['shopa', 'example']   (a slice: from position 1 to the end)
print(".".join(labels[1:]))   # shopa.example     (glue a list back together with dots)

print("shopa.example.".rstrip("."))   # shopa.example   (remove dots from the right end)
print("co.uk" in {"co.uk", "uk"})     # True   (a set answers "is this in it?" quickly)

for i in range(3):       # i takes the values 0, 1, 2
    print(i)

एक बढ़िया तरकीब: अगर आप endings को सबसे लंबी (labels[0:]) से सबसे छोटी तक आज़माएँ, तो सूची पर मिली पहली अपने आप सबसे लंबा मेल है।

आज़माएँ code लिखने से पहले, तीन हाथ से करें: www.alice.pages.example, news.practice-paper.co.uk और zz। आपको alice.pages.example, practice-paper.co.uk और zz मिलने चाहिए।

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

असली प्रोजेक्ट अपनी के बजाय public suffix list की एक रखरखाव वाली copy इस्तेमाल करते हैं:

// JavaScript (the tldts package)
import { getDomain } from "tldts";
getDomain("https://cdn.shopa.co.uk/lib.js");   // "shopa.co.uk"
getDomain("alice.github.io", { allowPrivateDomains: true });   // "alice.github.io" (private suffixes are off by default)
new URL("https://CDN.ShopA.example:8443/").hostname;   // "cdn.shopa.example"

// Go (golang.org/x/net/publicsuffix)
site, err := publicsuffix.EffectiveTLDPlusOne("alice.github.io")   // "alice.github.io", nil

// Rust (the psl crate)
let site = psl::domain_str("www.shopa.co.uk");   // Some("shopa.co.uk")

// C# (built in: host only; use a public-suffix package such as Nager.PublicSuffix for the site)
var host = new Uri("https://CDN.ShopA.example:8443/").Host;   // "cdn.shopa.example"

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

"एक ही साइट का मतलब एक ही origin, बस ढीले शब्दों में।" ये अलग सीमाएँ हैं। Origin वह है जो JavaScript पन्नों को अलग रखने के लिए इस्तेमाल करता है (कौन किसका डेटा पढ़ सकता है)। Site वह है जो निजता features यह तय करने के लिए इस्तेमाल करते हैं कि एक पक्ष क्या गिना जाए (किसकी cookies जाती हैं, एक embed को कौन-सा jar मिलता है)। www.shopa.example और shopa.example अलग origins हैं पर एक साइट।

सार

  • एक साइट public suffix और एक label है; public suffix list बताती है कि suffixes कहाँ ख़त्म होते हैं।
  • सबसे लंबा सूचीबद्ध suffix जीतता है, और github.io जैसे private suffixes हर उपयोगकर्ता की उप-साइट को उसकी अपनी साइट बनाते हैं।
  • Schemeful same-site scheme गिनता है, इसलिए एक domain के http और https वर्ज़न अलग साइटें हैं।
  • Origins पन्नों को अलग रखते हैं; sites तय करती हैं कि कौन-सा पक्ष कौन है।
आपकी बारी

चार functions लिखें, फिर उन्हें 30 अभ्यास URLs पर इस्तेमाल करें।

  1. host_from_url(url): url का host, lower case में, बिना port और बिना आख़िरी बिंदु के।
  2. site_for(url, suffixes): url की साइट, set suffixes को public suffix list के रूप में और पाठ के पाँच नियमों को इस्तेमाल करते हुए (सबसे लंबा सूचीबद्ध suffix और एक label; जो host ख़ुद एक suffix है वह अपनी साइट है; अगर कुछ मेल न खाए, तो आख़िरी label suffix है)।
  3. schemeful_site(url, suffixes): scheme, फिर ://, फिर साइट, उदाहरण के लिए "https://shopa.example"।
  4. is_same_site(a, b, suffixes): True जब दोनों URLs की schemeful साइट एक हो।
आख़िर में SITES को एक सूची पर सेट करें जिसमें PRACTICE_URLS के हर URL की साइट हो, क्रम में, PRACTICE_SUFFIXES इस्तेमाल करते हुए। logic ख़ुद लिखें: watched से site_of या same_site इस्तेमाल न करें।

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

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

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