Hachage et URL

Ce document s'applique à la méthode suivante: API Update (v4): fullHashes.find.

Présentation

Les listes de navigation sécurisée sont constituées de hachages SHA256 de longueur variable (voir la section Contenu de la liste). Pour comparer une URL à une liste de navigation sécurisée (en local ou sur le serveur), les clients doivent d'abord pour calculer le préfixe de hachage de cette URL.

Pour calculer le préfixe de hachage d'une URL, procédez comme suit :

1. Choisissez une URL canonique (voir Choix de l'URL canonique).
2. Créez les expressions de suffixe/préfixe pour l'URL (voir la section Expressions de suffixe/préfixe).
3. Calculer le hachage complet pour chaque suffixe/expression de préfixe (voir Calculs de hachage).
4. Calculez le préfixe de hachage pour chaque hachage complet (voir Calculs du préfixe de hachage).

Notez que ces étapes reflètent le processus utilisé par le serveur de navigation sécurisée pour maintenir le protocole Parcourir des listes

Choix de l'URL canonique

Pour commencer, nous supposons que le client a analysé l'URL et l'a validée conformément à la norme RFC 2396. Si l'URL utilise un nom de domaine internationalisé (IDN), le client doit convertir l'URL en une syntaxe Punycode ASCII. L'URL doit inclure un composant de chemin d'accès. c'est-à-dire qu'elle doit comporter barre oblique finale ("http://google.com/").

Commencez par supprimer les caractères de tabulation (0x09), de RS (0x0d) et de gauche (0x0a) des l'URL. Ne supprimez pas les séquences d'échappement de ces caractères (par exemple, "%0a").

Ensuite, si l'URL se termine par un fragment, supprimez-le. Par exemple, raccourcissez "http://google.com/#frag" en "http://google.com/".

Enfin, supprimez les échappements de pourcentage de l'URL jusqu'à ce qu'il n'y en ait plus.

Pour canoniser le nom d'hôte:

Extrayez le nom d'hôte de l'URL, puis procédez comme suit :

1. Supprimez tous les points au début et à la fin.
2. Remplacez les points consécutifs par un seul point.
3. Si le nom d'hôte peut être analysé en tant qu'adresse IP, normalisez-le à 4 valeurs décimales séparées par un point. Le client doit gérer tout encodage d'adresse IP légitime, y compris les valeurs octales, hexadécimales et moins de quatre composants.
4. Mettre la chaîne en minuscules.

Pour définir le chemin canonique:

1. Résoudre les séquences "/../" et "/./" dans le chemin en en remplaçant "/./" avec "/", et en supprimant "/../" ainsi que le chemin précédent .
2. Remplacez les séries de barres obliques consécutives par une seule barre oblique.

N'appliquez pas ces méthodes de mise en forme canonique du chemin aux paramètres de requête.

Dans l'URL, appliquez des échappements de pourcentage à tous les caractères qui sont : <= ASCII 32, >= 127, "#" ou "%". Les échappements doivent utiliser des caractères hexadécimaux en majuscules.

Vous trouverez ci-dessous des tests permettant de valider une mise en œuvre canonique.

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";

Expressions de suffixe/préfixe

Une fois l'URL mise en forme canonique, l'étape suivante consiste à créer les expressions de suffixe/préfixe. Chaque expression de suffixe/préfixe se compose d'un suffixe d'hôte (ou hôte complet) et d'un préfixe de chemin (ou chemin d'accès complet), comme indiqué dans ces exemples.

a.b/mypath/

http\:\/\/.*\.a\.b\/mypath\/.*

c.d/full/path.html?myparam=a

http\:\/\/.*.c\.d\/full\/path\.html?myparam=a

Le client formera jusqu'à 30 combinaisons possibles de suffixe d'hôte et de préfixe de chemin. Ces combinaisons n'utilisent que les composants hôte et de chemin d'accès de l'URL. Le schéma, le nom d'utilisateur, le mot de passe et le port sont supprimés. Si l'URL inclut des paramètres de requête, au moins une combinaison inclut le chemin complet et les paramètres de requête.

Pour l'hôte, le client essaie au maximum cinq chaînes différentes. À savoir :

• Le nom d'hôte exact dans l'URL.
• Jusqu'à quatre noms d'hôte créés en commençant par les cinq derniers composants et en supprimant successivement le composant au début. Le domaine de premier niveau peut être ignoré. Ces les noms d’hôte supplémentaires ne doivent pas être vérifiés si l’hôte est une adresse IP.

Pour le chemin, le client essaie au maximum six chaînes différentes. Ils sont:

• Le chemin d'accès exact de l'URL, y compris les paramètres de requête.
• Le chemin d'accès exact de l'URL, sans paramètres de requête.
• Les quatre chemins créés en partant de la racine (/) et en ajoutant successivement les composants de chemin, y compris une barre oblique finale.

Les exemples suivants illustrent le comportement de la vérification :

Pour l'URL http://a.b.c/1/2.html?param=1, le client effectuera les opérations suivantes : chaînes possibles:

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/

Pour l'URL http://a.b.c.d.e.f.g/1.html, le client essaie les chaînes possibles suivantes :

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/

Pour l'URL http://1.2.3.4/1/, le client essaie les chaînes possibles suivantes :

1.2.3.4/1/
1.2.3.4/

Calculs de hachage

Une fois l'ensemble d'expressions de suffixe/préfixe créé, l'étape suivante consiste à calculer la un hachage SHA256 complet pour chaque expression. Un test unitaire (en pseudo-C) que vous pouvez utiliser pour valider votre les calculs de hachage sont fournis ci-dessous.

Exemples de la norme 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]);

Calculs du préfixe de hachage

Exemples de la norme FIPS-180-2 :

• Exemple B1 de la norme FIPS-180-2
  • La valeur saisie est "abc".
  • Le condensé SHA256 est ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad.
  • Le préfixe de hachage 32 bits est ba7816bf.
• Exemple B2 de la norme FIPS-180-2
  • La valeur saisie est "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq".
  • Le condensé SHA256 est 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1.
  • Le préfixe de hachage de 48 bits est 248d6a61 d206.