Hachage d'un fichier en Python

Je veux que python lise l'EOF afin que je puisse obtenir un hachage approprié, que ce soit sha1 ou md5. Veuillez aider. Voici ce que j'ai jusqu'à présent:

import hashlib

inputFile = raw_input("Enter the name of the file:")
openedFile = open(inputFile)
readFile = openedFile.read()

md5Hash = hashlib.md5(readFile)
md5Hashed = md5Hash.hexdigest()

sha1Hash = hashlib.sha1(readFile)
sha1Hashed = sha1Hash.hexdigest()

print "File Name: %s" % inputFile
print "MD5: %r" % md5Hashed
print "SHA1: %r" % sha1Hashed

TL; DR utilise des tampons pour ne pas utiliser des tonnes de mémoire.

Nous arrivons au cœur de votre problème, je crois, lorsque nous considérons les implications mémoire du travail avec de très gros fichiers . Nous ne voulons pas que ce mauvais garçon produise 2 Go de RAM pour un fichier de 2 Go , donc, comme le souligne pasztorpisti , nous devons traiter ces fichiers plus gros par morceaux!

import sys
import hashlib

# BUF_SIZE is totally arbitrary, change for your app!
BUF_SIZE = 65536  # lets read stuff in 64kb chunks!

md5 = hashlib.md5()
sha1 = hashlib.sha1()

with open(sys.argv[1], 'rb') as f:
    while True:
        data = f.read(BUF_SIZE)
        if not data:
            break
        md5.update(data)
        sha1.update(data)

print("MD5: {0}".format(md5.hexdigest()))
print("SHA1: {0}".format(sha1.hexdigest()))

Ce que nous avons fait, c'est que nous mettons à jour nos hachages de ce mauvais garçon en morceaux de 64 Ko au fur et à mesure que nous suivons la méthode pratique de mise à jour dandy de hashlib . De cette façon, nous utilisons beaucoup moins de mémoire que les 2 Go qu'il faudrait pour hacher le gars en même temps!

Vous pouvez tester cela avec:

$ mkfile 2g bigfile
$ python hashes.py bigfile
MD5: a981130cf2b7e09f4686dc273cf7187e
SHA1: 91d50642dd930e9542c39d36f0516d45f4e1af0d
$ md5 bigfile
MD5 (bigfile) = a981130cf2b7e09f4686dc273cf7187e
$ shasum bigfile
91d50642dd930e9542c39d36f0516d45f4e1af0d  bigfile

J'espère que cela pourra aider!

Tout cela est également décrit dans la question liée sur le côté droit: Obtenez le hachage MD5 de gros fichiers en Python

Addenda!

En général, lors de l'écriture de python, il est utile de prendre l'habitude de suivre pep-8 . Par exemple, en python, les variables sont généralement séparées par des traits de soulignement et non par camelCased. Mais ce n'est que du style et personne ne se soucie vraiment de ces choses, sauf les gens qui doivent lire le mauvais style ... ce qui pourrait être vous en lisant ce code dans des années.

Pour le calcul correct et efficace de la valeur de hachage d'un fichier (en Python 3):

• Ouvrez le fichier en mode binaire (c.-à-d. 'b' à- au mode fichier) pour éviter les problèmes de codage de caractères et de conversion de fin de ligne.
• Ne lisez pas le fichier complet en mémoire, car c'est une perte de mémoire. Au lieu de cela, lisez-le séquentiellement bloc par bloc et mettez à jour le hachage pour chaque bloc.
• Éliminez le double tampon, c'est-à-dire n'utilisez pas d'E / S tamponnées, car nous utilisons déjà une taille de bloc optimale.
• Utilisez readinto()pour éviter le barattage du tampon.

Exemple:

import hashlib

def sha256sum(filename):
    h  = hashlib.sha256()
    b  = bytearray(128*1024)
    mv = memoryview(b)
    with open(filename, 'rb', buffering=0) as f:
        for n in iter(lambda : f.readinto(mv), 0):
            h.update(mv[:n])
    return h.hexdigest()

Je proposerais simplement:

def get_digest(file_path):
    h = hashlib.sha256()

    with open(file_path, 'rb') as file:
        while True:
            # Reading is buffered, so we can read smaller chunks.
            chunk = file.read(h.block_size)
            if not chunk:
                break
            h.update(chunk)

    return h.hexdigest()

Toutes les autres réponses ici semblent trop compliquer. Python met déjà en mémoire tampon lors de la lecture (de manière idéale, ou vous configurez cette mise en mémoire tampon si vous avez plus d'informations sur le stockage sous-jacent) et il est donc préférable de lire par morceaux que la fonction de hachage trouve idéale, ce qui la rend plus rapide ou au moins moins gourmande en CPU pour calculer la fonction de hachage. Ainsi, au lieu de désactiver la mise en mémoire tampon et d'essayer de l'émuler vous-même, vous utilisez la mise en mémoire tampon Python et contrôlez ce que vous devriez contrôler: ce que le consommateur de vos données trouve idéal, la taille du bloc de hachage.

J'ai programmé un module capable de hacher de gros fichiers avec différents algorithmes.

pip3 install py_essentials

Utilisez le module comme ceci:

from py_essentials import hashing as hs
hash = hs.fileChecksum("path/to/the/file.txt", "sha256")

Voici une solution Python 3, POSIX (pas Windows!) Qui utilise mmappour mapper l'objet en mémoire.

import hashlib
import mmap

def sha256sum(filename):
    h  = hashlib.sha256()
    with open(filename, 'rb') as f:
        with mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ) as mm:
            h.update(mm)
    return h.hexdigest()

import hashlib
user = input("Enter ")
h = hashlib.md5(user.encode())
h2 = h.hexdigest()
with open("encrypted.txt","w") as e:
    print(h2,file=e)


with open("encrypted.txt","r") as e:
    p = e.readline().strip()
    print(p)