Real Time Mode

Lorsque les clients choisissent d'utiliser la navigation sécurisée Google v5 en mode temps réel, ils conservent dans leur base de données locale : (i) un cache global des sites probablement fiables, mis en forme sous forme de hachages SHA256 des expressions d'URL de suffixe d'hôte/préfixe de chemin d'accès, (ii) un ensemble de listes de menaces, mis en forme sous forme de préfixes de hachage SHA256 des expressions d'URL de suffixe d'hôte/préfixe de chemin d'accès. L'idée générale est que chaque fois que le client souhaite vérifier une URL spécifique, une vérification locale est effectuée à l'aide du cache global. Si cette vérification réussit, une vérification des listes de menaces locales est effectuée. Sinon, le client poursuit la vérification du hachage en temps réel, comme indiqué ci-dessous.

En plus de la base de données locale, le client conservera un cache local. Ce cache local n'a pas besoin d'être dans un stockage persistant et peut être effacé en cas de pression sur la mémoire.

Vous trouverez ci-dessous une description détaillée de la procédure.

Procédure de vérification des URL en temps réel

Cette procédure prend une seule URL u et renvoie SAFE, UNSAFE ou UNSURE. Si elle renvoie SAFE, l'URL est considérée comme sécurisée par la navigation sécurisée Google. Si la réponse est UNSAFE, l'URL est considérée comme potentiellement dangereuse par la navigation sécurisée de Google. Vous devez alors prendre les mesures appropriées, par exemple afficher un avertissement à l'utilisateur final, déplacer un message reçu dans le dossier de spams ou demander à l'utilisateur une confirmation supplémentaire avant de continuer. Si la valeur renvoyée est UNSURE, la procédure de vérification locale suivante doit être utilisée.

1. Soit expressions une liste d'expressions de suffixe/préfixe générées par l'URL u.
2. Soit expressionHashes une liste dont les éléments sont les hachages SHA256 de chaque expression dans expressions.
3. Pour chaque hash de expressionHashes :
   1. Si hash est introuvable dans le cache global, renvoie UNSURE.
4. Soit expressionHashPrefixes une liste dont les éléments sont les quatre premiers octets de chaque hachage dans expressionHashes.
5. Pour chaque expressionHashPrefix de expressionHashPrefixes :
   1. Recherchez expressionHashPrefix dans le cache local.
   2. Si l'entrée en cache est trouvée :
      1. Déterminez si l'heure actuelle est postérieure à son heure d'expiration.
      2. Si elle est supérieure :
         1. Supprime l'entrée mise en cache trouvée du cache local.
         2. Continuez avec la boucle.
      3. Si elle n'est pas supérieure :
         1. Supprimez ce expressionHashPrefix de expressionHashPrefixes.
         2. Vérifiez si le hachage complet correspondant dans expressionHashes se trouve dans l'entrée mise en cache.
         3. Si elle est trouvée, renvoie UNSAFE.
         4. Si vous ne le trouvez pas, continuez la boucle.
   3. Si l'entrée mise en cache est introuvable, poursuivez la boucle.
6. Envoyez expressionHashPrefixes au serveur Google Navigation sécurisée v5 à l'aide de RPC SearchHashes ou de la méthode REST hashes.search. Si une erreur s'est produite (y compris des erreurs réseau, des erreurs HTTP, etc.), renvoyez UNSURE. Sinon, la réponse est le response reçu du serveur SB, qui est une liste de hachages complets avec des informations auxiliaires identifiant la nature de la menace (ingénierie sociale, logiciel malveillant, etc.), ainsi que le délai d'expiration du cache expiration.
7. Pour chaque fullHash de response :
   1. Insérez fullHash dans le cache local, ainsi que expiration.
8. Pour chaque fullHash de response :
   1. Soit isFound le résultat de la recherche de fullHash dans expressionHashes.
   2. Si isFound est défini sur "False", la boucle continue.
   3. Si isFound est "true", renvoie UNSAFE.
9. Renvoyez SAFE.

Bien que ce protocole spécifie quand le client envoie expressionHashPrefixes au serveur, il ne spécifie pas exactement comment les envoyer. Par exemple, le client peut envoyer tous les expressionHashPrefixes dans une seule requête, ou envoyer chaque préfixe individuel dans expressionHashPrefixes au serveur dans des requêtes distinctes (éventuellement en parallèle). Le client peut également envoyer des préfixes de hachage non liés ou générés de manière aléatoire avec les préfixes de hachage dans expressionHashPrefixes, à condition que le nombre de préfixes de hachage envoyés dans une seule requête ne dépasse pas 30.