Cette page a été traduite par l'API Cloud Translation.
Switch to English

Hachage d'URL

Présentation

Les listes Web Risk sont constituées de hachages SHA256 de longueur variable. Pour en savoir plus, consultez la section Contenu de la liste. Pour comparer une URL à une liste Web Risk, localement ou sur le serveur, les clients doivent d'abord calculer le préfixe de hachage de cette URL.

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

  1. Créez une URL canonique comme décrit dans la section Mise en forme canonique.
  2. Créez les expressions de suffixe/préfixe pour l'URL comme décrit dans la section Expressions de suffixe/préfixe.
  3. Calculez le hachage complet pour chaque expression de suffixe/préfixe comme décrit dans la section Calculs de hachage.
  4. Calculez le préfixe de hachage pour chaque hachage complet, comme décrit dans la section Calculs du préfixe de hachage.

Notez que ces étapes reflètent le processus utilisé par le serveur Web Risk pour gérer les listes Web Risk.

Mise en forme 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 international (IDN), le client doit convertir l'URL en une syntaxe Punycode ASCII. L'URL doit inclure un chemin, c'est-à-dire qu'elle doit comporter une barre oblique (http://google.com/).

Tout d'abord, supprimez les caractères de tabulation (0x09), CR (0x0d) et LF (0x0a) de l'URL. Ne supprimez pas les séquences d'échappement de ces caractères, comme %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 mettre en forme canonique 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 en y indiquant 4 valeurs décimales séparées par des points. 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 mettre en forme canonique le chemin

  1. Corrigez les séquences /../ et /./ du chemin en remplaçant /./ par / et en supprimant /../ avec le composant de 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.

Expression de suffixe/préfixe Expression régulière équivalente
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 d'hôte et de chemin 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 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. À savoir :

  • 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 essaie les chaînes possibles suivantes :

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 que l'ensemble d'expressions de suffixe/préfixe a été créé, l'étape suivante consiste à calculer le hachage SHA256 complet pour chaque expression. Vous trouverez ci-dessous un test unitaire en pseudo-C que vous pouvez utiliser pour valider vos calculs de hachage.

Exemples de la norme FIPS-180-2 :


// 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

Enfin, le client doit calculer le préfixe de hachage pour chaque hachage SHA256 complet. Pour Web Risk, un préfixe de hachage se compose des 4 à 32 octets les plus significatifs d'un hachage SHA256.

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
    • L'entrée est abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq.
    • Le condensé SHA256 est 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1.
    • Le préfixe de hachage 48 bits est 248d6a61 d206.