यूआरएल और हैशिंग

यह दस्तावेज़ नीचे दिए गए तरीके पर लागू होता है: एपीआई अपडेट करें (v4): fullHashes.find.

खास जानकारी

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

किसी यूआरएल के हैश प्रीफ़िक्स का हिसाब लगाने के लिए, यह तरीका अपनाएं:

  1. यूआरएल को कैननिकल बनाना (यूआरएल के कैननिकल होने की जांच करना देखें).
  2. यूआरएल के लिए सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन बनाना (सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन देखें).
  3. हर सफ़िक्स/प्रीफ़िक्स एक्सप्रेशन के लिए, पूरी लंबाई वाले हैश का इस्तेमाल करें (हैश कंप्यूटेशन देखें).
  4. हर पूरी लंबाई वाले हैश के लिए हैश प्रीफ़िक्स का इस्तेमाल करें (हैश प्रीफ़िक्स कंप्यूटेशन देखें).

ध्यान दें कि ये चरण उस प्रक्रिया की जानकारी देते हैं जिसका इस्तेमाल सुरक्षित ब्राउज़िंग सर्वर, ब्राउज़िंग सूचियां.

यूआरएल के कैननिकल होने की जांच करना

सबसे पहले, हम यह मानते हैं कि क्लाइंट ने यूआरएल को पार्स कर लिया है और आरएफ़सी 2396 के मुताबिक उसे मान्य बना दिया है. अगर यूआरएल में अंतरराष्ट्रीय डोमेन नेम (आईडीएन) का इस्तेमाल किया गया है, तो क्लाइंट को यूआरएल को ASCII प्यूनीकोड में बदलना चाहिए. यूआरएल में कोई पाथ कॉम्पोनेंट शामिल होना चाहिए; इसका मतलब है कि उसमें ट्रेलिंग स्लैश ("http://google.com/").

सबसे पहले, यूआरएल से टैब (0x09), सीआर (0x0d), और LF (0x0a) वर्ण हटाएं. इन वर्णों के लिए एस्केप सीक्वेंस न हटाएं, जैसे कि '%0a'.

दूसरा, अगर यूआरएल किसी फ़्रैगमेंट पर खत्म होता है, तो फ़्रैगमेंट हटाएं. उदाहरण के लिए, "http://google.com/#frag" को "http://google.com/" पर छोटा करें.

तीसरा, यूआरएल को बार-बार प्रतिशत से अनएस्केप करें, जब तक कि उसमें प्रतिशत से अनएस्केप करने की कोई ज़रूरत न हो.

होस्टनेम का कैननिकल वर्शन बनाने के लिए:

यूआरएल से होस्टनेम निकालें और इसके बाद:

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

पाथ को कैननिकल बनाने के लिए:

  1. क्रम "/../" को हल करें और "/./" के पाथ में "/./" को बदला जा रहा है "/" के साथ और "/../" को हटाएं पिछले पाथ के साथ कॉम्पोनेंट.
  2. लगातार स्लैश वर्ण चलाए जाने की जगह, एक स्लैश वर्ण का इस्तेमाल करें.

क्वेरी पैरामीटर के लिए, पाथ के कैननिकल होने की ये जांच लागू न करें.

यूआरएल में, सभी वर्णों का प्रतिशत-एस्केप जो <= 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 के लिए, क्लाइंट ये तरीके आज़माएगा strings:

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 का उदाहरण
    • इनपुट है "abcdbcdecdefdefgefkhfghighijhijkijkljklmklmnlmnlmnomnopnopq".
    • SHA256 डाइजेस्ट 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 है 64ff2167 f6ecedd4 19db06c1.
    • 48-बिट हैश प्रीफ़िक्स 248d6a61 d206 है.