यह दस्तावेज़ इस तरीके पर लागू होता है: एपीआई (v4) अपडेट करें: fullHashes.find.
खास जानकारी
सुरक्षित ब्राउज़िंग की सूचियों में अलग-अलग लंबाई वाले SHA256 हैश होते हैं (सूची कॉन्टेंट देखें). किसी यूआरएल की सुरक्षित ब्राउज़िंग सूची (स्थानीय तौर पर या सर्वर पर) से मिलान करने के लिए, क्लाइंट को पहले उस यूआरएल के हैश प्रीफ़िक्स की गिनती करनी होगी.
किसी यूआरएल के हैश प्रीफ़िक्स का पता लगाने के लिए, यह तरीका अपनाएं:
- यूआरएल को कैननिकल बनाना (कैननिकल की जानकारी देना देखें).
- यूआरएल के लिए सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन बनाएं (सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन देखें).
- हर सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन के लिए, पूरी लंबाई वाले हैश का हिसाब लगाएं (हैश कंप्यूटेशन देखें).
- हर पूरी लंबाई वाले हैश के लिए हैश प्रीफ़िक्स की गणना करें (हैश प्रीफ़िक्स कंप्यूटेशन देखें).
ध्यान दें कि ये चरण उसी प्रोसेस की मिररिंग करते हैं जिसका इस्तेमाल सुरक्षित ब्राउज़िंग की सूचियों को बनाए रखने के लिए किया जाता है.
यूआरएल के कैननिकल होने की जांच करना
शुरू करने के लिए, हम मानते हैं कि क्लाइंट ने यूआरएल को पार्स कर लिया है और उसे आरएफ़सी 2396 के मुताबिक मान्य बना दिया है. अगर यूआरएल किसी अंतरराष्ट्रीय डोमेन नाम (आईडीएन) का इस्तेमाल करता है, तो क्लाइंट को यूआरएल को ASCII पनीकोड में बदलने चाहिए. यूआरएल में पाथ कॉम्पोनेंट शामिल होना चाहिए. इसका मतलब है कि यूआरएल के आखिर में स्लैश ("http://google.com/") मौजूद होना चाहिए.
सबसे पहले, यूआरएल से टैब (0x09), सीआर (0x0d), और एलएफ़ (0x0a) के वर्ण हटाएं. इन वर्णों के लिए एस्केप सीक्वेंस न हटाएं, जैसे कि '%0a'.
दूसरा, अगर यूआरएल किसी फ़्रैगमेंट पर खत्म होता है, तो फ़्रैगमेंट हटा दें. उदाहरण के लिए, "http://google.com/#frag" को छोटा करके "http://google.com/" करें.
तीसरा, यूआरएल को बार-बार पर्सनल-एस्केप करें, जब तक कि उसमें और प्रतिशत-एस्केप न हों.
होस्टनेम के यूआरएल को कैननिकल करने के लिए:
यूआरएल से होस्टनेम निकालें और फिर:
- शुरू और पीछे के सभी बिंदु हटा दें.
- लगातार आने वाले बिंदुओं को एक बिंदु से बदलें.
- अगर होस्टनेम को आईपी पते के तौर पर पार्स किया जा सकता है, तो उसे चार डॉट से अलग की गई दशमलव वैल्यू पर नॉर्मलाइज़ करें. क्लाइंट को आईपी पते को कोड में बदलने के सभी कानूनी तरीकों को हैंडल करना चाहिए. इसमें ऑक्टल, हेक्स, और चार से कम कॉम्पोनेंट शामिल हैं.
- पूरी स्ट्रिंग लोअरकेस में कर दें.
पाथ के कैननिकल होने की जांच करने के लिए:
- "/./" की जगह "/" और पिछले पाथ कॉम्पोनेंट के साथ "/../" को हटाकर, पाथ में क्रम "/../" और "/./" को हल करें.
- लगातार होने वाले स्लैश को एक स्लैश वर्ण से बदलें.
क्वेरी पैरामीटर पर इन पाथ के कैननिकल होने की जांच न करें.
यूआरएल में, उन सभी वर्णों को प्रतिशत-एस्केप में शामिल करें जो <= ASCII 32, >= 127, "#" या "%" हैं. एस्केप में अपरकेस हेक्स वर्णों का इस्तेमाल किया जाना चाहिए.
नीचे दिए गए टेस्ट से, यूआरएल के कैननिकल होने की पुष्टि करने में मदद मिलती है.
Canonicalize("http://host/%25%32%35") = "http://host/%25";
Canonicalize("http://host/%25%32%35%25%32%35") = "http://host/%25%25";
Canonicalize("http://host/%2525252525252525") = "http://host/%25";
Canonicalize("http://host/asdf%25%32%35asd") = "http://host/asdf%25asd";
Canonicalize("http://host/%%%25%32%35asd%%") = "http://host/%25%25%25asd%25%25";
Canonicalize("http://www.google.com/") = "http://www.google.com/";
Canonicalize("http://%31%36%38%2e%31%38%38%2e%39%39%2e%32%36/%2E%73%65%63%75%72%65/%77%77%77%2E%65%62%61%79%2E%63%6F%6D/") = "http://168.188.99.26/.secure/www.ebay.com/";
Canonicalize("http://195.127.0.11/uploads/%20%20%20%20/.verify/.eBaysecure=updateuserdataxplimnbqmn-xplmvalidateinfoswqpcmlx=hgplmcx/") = "http://195.127.0.11/uploads/%20%20%20%20/.verify/.eBaysecure=updateuserdataxplimnbqmn-xplmvalidateinfoswqpcmlx=hgplmcx/";
Canonicalize("http://host%23.com/%257Ea%2521b%2540c%2523d%2524e%25f%255E00%252611%252A22%252833%252944_55%252B") = "http://host%23.com/~a!b@c%23d$e%25f^00&11*22(33)44_55+";
Canonicalize("http://3279880203/blah") = "http://195.127.0.11/blah";
Canonicalize("http://www.google.com/blah/..") = "http://www.google.com/";
Canonicalize("www.google.com/") = "http://www.google.com/";
Canonicalize("www.google.com") = "http://www.google.com/";
Canonicalize("http://www.evil.com/blah#frag") = "http://www.evil.com/blah";
Canonicalize("http://www.GOOgle.com/") = "http://www.google.com/";
Canonicalize("http://www.google.com.../") = "http://www.google.com/";
Canonicalize("http://www.google.com/foo\tbar\rbaz\n2") ="http://www.google.com/foobarbaz2";
Canonicalize("http://www.google.com/q?") = "http://www.google.com/q?";
Canonicalize("http://www.google.com/q?r?") = "http://www.google.com/q?r?";
Canonicalize("http://www.google.com/q?r?s") = "http://www.google.com/q?r?s";
Canonicalize("http://evil.com/foo#bar#baz") = "http://evil.com/foo";
Canonicalize("http://evil.com/foo;") = "http://evil.com/foo;";
Canonicalize("http://evil.com/foo?bar;") = "http://evil.com/foo?bar;";
Canonicalize("http://\x01\x80.com/") = "http://%01%80.com/";
Canonicalize("http://notrailingslash.com") = "http://notrailingslash.com/";
Canonicalize("http://www.gotaport.com:1234/") = "http://www.gotaport.com/";
Canonicalize(" http://www.google.com/ ") = "http://www.google.com/";
Canonicalize("http:// leadingspace.com/") = "http://%20leadingspace.com/";
Canonicalize("http://%20leadingspace.com/") = "http://%20leadingspace.com/";
Canonicalize("%20leadingspace.com/") = "http://%20leadingspace.com/";
Canonicalize("https://www.securesite.com/") = "https://www.securesite.com/";
Canonicalize("http://host.com/ab%23cd") = "http://host.com/ab%23cd";
Canonicalize("http://host.com//twoslashes?more//slashes") = "http://host.com/twoslashes?more//slashes";
सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन
यूआरएल के कैननिकल होने के बाद, अगला चरण सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन बनाना है. जैसा कि इन उदाहरणों में दिखाया गया है, हर फ़िक्स/प्रीफ़िक्स एक्सप्रेशन में एक होस्ट सफ़िक्स (या पूरा होस्ट) और एक पाथ प्रीफ़िक्स (या पूरा पाथ) होता है.
| सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन | इक्विवैलेंट रेगुलर एक्सप्रेशन |
|---|---|
a.b/mypath/ | http\:\/\/.*\.a\.b\/mypath\/.* |
c.d/full/path.html?myparam=a | http\:\/\/.*.c\.d\/full\/path\.html?myparam=a |
क्लाइंट, होस्ट सफ़िक्स और पाथ प्रीफ़िक्स के 30 अलग-अलग संभावित कॉम्बिनेशन बनाएगा. ये कॉम्बिनेशन, यूआरएल के सिर्फ़ होस्ट और पाथ कॉम्पोनेंट का इस्तेमाल करते हैं. स्कीम, उपयोगकर्ता नाम, पासवर्ड, और पोर्ट को खारिज कर दिया जाता है. अगर यूआरएल में क्वेरी पैरामीटर शामिल हैं, तो कम से कम एक कॉम्बिनेशन में पूरा पाथ और क्वेरी पैरामीटर शामिल होंगे.
होस्ट के लिए, क्लाइंट ज़्यादा से ज़्यादा पांच अलग-अलग स्ट्रिंग को आज़माएगा. ये वजह हैं:
- यूआरएल में मौजूद सटीक होस्टनेम.
- ज़्यादा से ज़्यादा चार होस्टनेम, जिन्हें आखिरी पांच कॉम्पोनेंट से शुरू करके और मुख्य कॉम्पोनेंट को क्रम से हटाकर बनाया जाता है. टॉप लेवल डोमेन को छोड़ा जा सकता है. अगर होस्ट कोई आईपी पता है, तो इन अतिरिक्त होस्टनेम की जांच नहीं की जानी चाहिए.
पाथ के लिए, क्लाइंट ज़्यादा से ज़्यादा छह अलग-अलग स्ट्रिंग आज़माएगा. वे ये हैं:
- क्वेरी पैरामीटर के साथ यूआरएल का सटीक पाथ.
- क्वेरी पैरामीटर के बिना, यूआरएल का सटीक पाथ.
- रूट (/) से शुरू करके और पाथ के कॉम्पोनेंट को क्रम से जोड़कर, चार पाथ बनाए जाते हैं. इनमें पाथ के पीछे लगने वाला स्लैश भी शामिल होता है.
ये उदाहरण जांच के तरीके को दिखाते हैं:
यूआरएल http://a.b.c/1/2.html?param=1 के लिए, क्लाइंट इन
संभावित स्ट्रिंग को आज़माएगा:
a.b.c/1/2.html?param=1 a.b.c/1/2.html a.b.c/ a.b.c/1/ b.c/1/2.html?param=1 b.c/1/2.html b.c/ b.c/1/
यूआरएल http://a.b.c.d.e.f.g/1.html के लिए, क्लाइंट इन संभावित स्ट्रिंग को
आज़माएगा:
a.b.c.d.e.f.g/1.html a.b.c.d.e.f.g/ (Note: skip b.c.d.e.f.g, since we'll take only the last five hostname components, and the full hostname) c.d.e.f.g/1.html c.d.e.f.g/ d.e.f.g/1.html d.e.f.g/ e.f.g/1.html e.f.g/ f.g/1.html f.g/
यूआरएल http://1.2.3.4/1/ के लिए, क्लाइंट इन संभावित स्ट्रिंग को
आज़माएगा:
1.2.3.4/1/ 1.2.3.4/
हैश कंप्यूटेशन
सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन का सेट बन जाने के बाद, अगला चरण हर एक्सप्रेशन के लिए पूरी लंबाई के SHA256 हैश का हिसाब लगाना है. हैश कंप्यूटेशन की पुष्टि करने के लिए, जिसका इस्तेमाल किया जा सकता है उसकी यूनिट टेस्ट (स्यूडो-सी में) नीचे दी गई है.
FIPS-180-2 से उदाहरण:
Unit Test (in pseudo-C)
// Example B1 from FIPS-180-2
string input1 = "abc";
string output1 = TruncatedSha256Prefix(input1, 32);
int expected1[] = { 0xba, 0x78, 0x16, 0xbf };
assert(output1.size() == 4); // 4 bytes == 32 bits
for (int i = 0; i < output1.size(); i++) assert(output1[i] == expected1[i]);
// Example B2 from FIPS-180-2
string input2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
string output2 = TruncatedSha256Prefix(input2, 48);
int expected2[] = { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06 };
assert(output2.size() == 6);
for (int i = 0; i < output2.size(); i++) assert(output2[i] == expected2[i]);
// Example B3 from FIPS-180-2
string input3(1000000, 'a'); // 'a' repeated a million times
string output3 = TruncatedSha256Prefix(input3, 96);
int expected3[] = { 0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92,
0x81, 0xa1, 0xc7, 0xe2 };
assert(output3.size() == 12);
for (int i = 0; i < output3.size(); i++) assert(output3[i] == expected3[i]);
हैश प्रीफ़िक्स कंप्यूटेशन
आखिर में, क्लाइंट को हर पूरी लंबाई वाले SHA256 हैश के लिए, हैश प्रीफ़िक्स का पता लगाना होगा. सुरक्षित ब्राउज़िंग के लिए, हैश प्रीफ़िक्स में SHA256 हैश की सबसे अहम 4-32 बाइट होती हैं.FIPS-180-2 से उदाहरण:
- FIPS-180-2 से B1 उदाहरण
- इनपुट "abc" है.
- SHA256 डाइजेस्ट ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad है.
- 32-बिट हैश प्रीफ़िक्स ba7816bf है.
- FIPS-180-2 से B2 उदाहरण
- इनपुट है "abcdbcdecdefgefghfghijhijkijkljklmklmnlmnomnopnopq".
- SHA256 डाइजेस्ट 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1 है.
- 48-बिट हैश प्रीफ़िक्स 248d6a61 d206 है.