Hachage et URL

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

Présentation

Les listes de navigation sécurisée sont constituées de hachages SHA256 de longueur variable (voir Liste du contenu). Pour comparer une URL à une liste de navigation sécurisée (en local 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. Définissez l'URL canonique (voir Mise en forme canonique).
  2. Créez les expressions de suffixe/préfixe pour l'URL (consultez la section Expressions de suffixe/préfixe).
  3. Calculez le hachage complet pour chaque expression de suffixe/préfixe (consultez la section Calculs de hachage).
  4. Calculez le préfixe de hachage pour chaque hachage complet (consultez la section Calculs des préfixes de hachage).

Notez que ces étapes reflètent le processus utilisé par le serveur de navigation sécurisée pour gérer les listes de navigation sécurisée.

Choix de l'URL canonique

Pour commencer, nous partons du principe que le client a analysé l'URL et l'a rendue valide conformément à la norme RFC 2396. Si l'URL utilise un nom de domaine internationalisé (IDN), le client doit la convertir en représentation Punycode ASCII. L'URL doit inclure un composant de chemin, c'est-à-dire qu'elle doit comporter une barre oblique finale ("http://google.com/").

Tout d'abord, supprimez de l'URL les caractères de tabulation (0x09), CR (0x0d) et LF (0x0a). Ne supprimez pas les séquences d'échappement pour ces caractères (par exemple, "%0a").

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

Troisièmement, supprimez plusieurs échappements avec le signe pourcentage pour supprimer l'échappement dans l'URL jusqu'à ce qu'il n'y ait plus aucun échappement avec le signe "%".

Pour choisir l'URL canonique du 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 quatre valeurs décimales séparées par un point. Le client doit gérer tout encodage d'adresse IP légal, y compris octal, hexadécimal et moins de quatre composants.
  4. Mettre la chaîne en minuscules.

Pour définir l'URL canonique du chemin d'accès:

  1. Résolve les séquences "/../" et "/./" du chemin d'accès en remplaçant "/./" par "/" et en supprimant "/../" ainsi que le composant du chemin d'accès 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, utilisez un échappement pour tous les caractères <= ASCII 32, >= 127, "#" ou "%". Les caractères d'échappement doivent utiliser des caractères hexadécimaux 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 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 d'un hôte complet) et d'un préfixe de chemin (ou d'un chemin d'accès complet), comme indiqué dans ces exemples.

Expression de suffixe/préfixeExpression 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 d'accès. Ces combinaisons n'utilisent que les composants d'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 inclura le chemin d'accès 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 formés en commençant par les cinq derniers composants et en supprimant successivement le composant principal Vous pouvez ignorer le domaine de premier niveau. Ces noms d'hôte supplémentaires ne doivent pas être vérifiés s'il s'agit d'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.
  • Quatre chemins formés en commençant à la racine (/) et en ajoutant successivement des 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 essayera les chaînes 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 essayera les chaînes 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 essayera les chaînes 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 le hachage SHA256 complet de chaque expression. Un test unitaire (en pseudo-C) que vous pouvez utiliser pour valider vos calculs de hachage est fourni 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

Enfin, le client doit calculer le préfixe de hachage pour chaque hachage SHA256 complet. Pour la navigation sécurisée, le préfixe de hachage correspond aux 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 de 32 bits est ba7816bf.
  • Exemple B2 de la norme FIPS-180-2
    • L'entrée est "abcdbcdecdefdefgefghfghijhijkijkljklmklmnlmnomnopnopq".
    • Le condensé SHA256 est 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1.
    • Le préfixe de hachage de 48 bits est 248d6a61 d206.