Le moyen le plus rapide d'indexer un gros fichier de hachage trié

ripgrep , comme tout autre outil capable de travailler avec des fichiers d'entrée non triés, n'est pas le bon outil pour ce travail. Lorsque vous essayez de grep des entrées triées, vous voulez quelque chose qui puisse couper en deux votre fichier d'entrée pour trouver une position en temps logarithmique. Pour des entrées suffisamment importantes, même une implémentation lente O (log n) sera plus rapide qu'une implémentation O (n) hautement optimisée.

pts-line-bisect en est un outil, mais bien sûr, vous êtes également invité à écrire le vôtre. Vous devrez l'écrire dans une langue avec un accès complet au syscall seek () , qui n'est pas exposé dans bash.

Vous lisez le fichier 256 fois, en effectuant une analyse complète du fichier à chaque fois. Envisagez une approche qui lit le fichier une fois, en écrivant chaque ligne dans un descripteur de fichier ouvert. Je pense que python serait un choix facile d'implémentation (si c'est votre truc). Vous pouvez optimiser en gardant le fichier ouvert jusqu'à ce que vous frappiez un nouveau code hexadécimal au début de la ligne. Si vous voulez être encore plus intelligent, il n'est pas nécessaire de parcourir le fichier trié ligne par ligne. Sur la base de l'indice de Charles Duffy, vous pouvez créer une heuristique pour échantillonner le fichier (en utilisant seek () ) pour obtenir la valeur hexadécimale suivante. Une fois que le programme a trouvé le décalage d'octet de la valeur hexadécimale suivante, le bloc d'octets peut être écrit dans le nouveau fichier. Cependant, comme il est étiqueté 'bash', gardons la solution définie dans ce domaine:

while 
  read line 
do
  hex=${line:0:2}
  echo $line >> ntlm/$hex-ntlm.txt
done < pwned-passwords-ntlm-ordered-by-hash-v4.txt

J'ai écrit un script Python3 qui résout les recherches rapides de recherche binaire dans le fichier de hachage sans avoir à créer un index. Il ne répond pas directement à votre question (indexation) mais résout probablement le problème sous-jacent que vous vouliez résoudre avec un index - rechercher rapidement des hachages individuels. Ce script vérifie des centaines de mots de passe en quelques secondes.

import argparse
import hashlib

parser = argparse.ArgumentParser(description='Searches passwords in https://haveibeenpwned.com/Passwords database.')
parser.add_argument('passwords', metavar='TEST', type=str, help='text file with passwords to test, one per line, utf-8')
parser.add_argument('database', metavar='DATABASE', type=str, help='the downloaded text file with sha-1:count')
args = parser.parse_args()

def search(f: object, pattern: str) -> str:

    def search(left, right: int) -> str:
        if left >= right:
            return None

        middle = (left + right) // 2
        if middle == 0:
            f.seek(0, 0)
            test = f.readline()
        else:
            f.seek(middle - 1, 0)
            _ = f.readline()
            test = f.readline()

        if test.upper().startswith(pattern):
            return test
        elif left == middle:
             return None
        elif pattern < test:
            return search(left, middle)
        else:
            return search(middle, right)

    f.seek(0, 2)
    return search(0, f.tell())

fsource = open(args.passwords)
fdatabase = open(args.database)
source_lines = fsource.readlines()
for l in source_lines:
    line = l.strip()
    hash_object = hashlib.sha1(line.encode("utf-8"))
    pattern = hash_object.hexdigest().upper()
    print("%s:%s" % (line, str(search(fdatabase, pattern)).strip()))
fsource.close()
fdatabase.close()