funcion - get hash python

Obtenga hash MD5 de grandes archivos en Python

Question

He usado hashlib (que reemplaza md5 en Python 2.6 / 3.0) y funcionó bien si abrí un archivo y puse su contenido en la función hashlib.md5() .

El problema es con archivos muy grandes que sus tamaños podrían exceder el tamaño de RAM.

¿Cómo obtener el hash MD5 de un archivo sin cargar todo el archivo en la memoria?

Answer 1

Aquí está mi versión del método de @Piotr Czapla:

def md5sum(filename):
    md5 = hashlib.md5()
    with open(filename, ''rb'') as f:
        for chunk in iter(lambda: f.read(128 * md5.block_size), b''''):
            md5.update(chunk)
    return md5.hexdigest()

Answer 2

Divida el archivo en trozos de 128 bytes y aliméntelos a MD5 consecutivamente usando update() .

Esto aprovecha el hecho de que MD5 tiene bloques de digestión de 128 bytes. Básicamente, cuando MD5 digest() el archivo, esto es exactamente lo que está haciendo.

Si se asegura de liberar la memoria en cada iteración (es decir, no leer todo el archivo en la memoria), esto no requerirá más de 128 bytes de memoria.

Un ejemplo es leer los trozos así:

f = open(fileName)
while not endOfFile:
    f.read(128)

Answer 3

Implementación de respuesta aceptada para Django:

import hashlib
from django.db import models


class MyModel(models.Model):
    file = models.FileField()  # any field based on django.core.files.File

    def get_hash(self):
        hash = hashlib.md5()
        for chunk in self.file.chunks(chunk_size=8192):
            hash.update(chunk)
        return hash.hexdigest()

Answer 4

Necesitas leer el archivo en trozos de tamaño adecuado:

def md5_for_file(f, block_size=2**20):
    md5 = hashlib.md5()
    while True:
        data = f.read(block_size)
        if not data:
            break
        md5.update(data)
    return md5.digest()

NOTA: asegúrese de abrir su archivo con ''rb'' al descubierto; de lo contrario, obtendrá un resultado incorrecto.

Entonces, para hacer todo en un método, use algo como:

def generate_file_md5(rootdir, filename, blocksize=2**20):
    m = hashlib.md5()
    with open( os.path.join(rootdir, filename) , "rb" ) as f:
        while True:
            buf = f.read(blocksize)
            if not buf:
                break
            m.update( buf )
    return m.hexdigest()

La actualización anterior se basó en los comentarios proporcionados por Frerich Raabe, y probé esto y lo encontré correcto en mi instalación de Windows Python 2.7.2

Verifiqué los resultados usando la herramienta ''jacksum''.

jacksum -a md5 <filename>

http://www.jonelo.de/java/jacksum/

Answer 5

No estoy seguro de que no haya demasiado alboroto aquí. Recientemente tuve problemas con md5 y archivos almacenados como blobs en MySQL, así que experimenté con varios tamaños de archivo y el enfoque directo de Python, a saber:

FileHash=hashlib.md5(FileData).hexdigest()

No pude detectar ninguna diferencia notable en el rendimiento con un rango de tamaños de archivo de 2Kb a 20Mb y, por lo tanto, no es necesario "dividir" el hash. De todos modos, si Linux tiene que ir al disco, probablemente lo hará al menos tan bien como la capacidad del programador promedio para evitar que lo haga. Como sucedió, el problema no tenía nada que ver con md5. Si está utilizando MySQL, no olvide las funciones md5 () y sha1 () que ya existen.

Answer 6

No puede obtener su md5 sin leer todo el contenido. pero puede usar la función de update para leer el contenido de los archivos bloque por bloque.
m.update (a); m.update (b) es equivalente a m.update (a + b)

Answer 7

Si le interesa la forma más pitonica (no "verdadera") de leer el archivo, consulte este código:

import hashlib

def checksum_md5(filename):
    md5 = hashlib.md5()
    with open(filename,''rb'') as f: 
        for chunk in iter(lambda: f.read(8192), b''''): 
            md5.update(chunk)
    return md5.digest()

Tenga en cuenta que iter () func necesita una cadena de bytes vacía para que el iterador devuelto se detenga en EOF, ya que read () devuelve b '''' (no solo '''').

Answer 8

Usando múltiples comentarios / respuestas en este hilo, esta es mi solución:

import hashlib
def md5_for_file(path, block_size=256*128, hr=False):
    ''''''
    Block size directly depends on the block size of your filesystem
    to avoid performances issues
    Here I have blocks of 4096 octets (Default NTFS)
    ''''''
    md5 = hashlib.md5()
    with open(path,''rb'') as f: 
        for chunk in iter(lambda: f.read(block_size), b''''): 
             md5.update(chunk)
    if hr:
        return md5.hexdigest()
    return md5.digest()

• Esto es "pitónico"
• Esta es una función
• Evita valores implícitos: siempre prefiere los explícitos.
• Permite optimizaciones de rendimiento (muy importantes)

Y finalmente,

- Esto ha sido creado por una comunidad, gracias a todos por sus consejos / ideas.

Answer 9

Una remezcla del código de Bastien Semene que toma en cuenta el comentario de Hawkwing acerca de la función hashing genérica ...

def hash_for_file(path, algorithm=hashlib.algorithms[0], block_size=256*128, human_readable=True):
    """
    Block size directly depends on the block size of your filesystem
    to avoid performances issues
    Here I have blocks of 4096 octets (Default NTFS)

    Linux Ext4 block size
    sudo tune2fs -l /dev/sda5 | grep -i ''block size''
    > Block size:               4096

    Input:
        path: a path
        algorithm: an algorithm in hashlib.algorithms
                   ATM: (''md5'', ''sha1'', ''sha224'', ''sha256'', ''sha384'', ''sha512'')
        block_size: a multiple of 128 corresponding to the block size of your filesystem
        human_readable: switch between digest() or hexdigest() output, default hexdigest()
    Output:
        hash
    """
    if algorithm not in hashlib.algorithms:
        raise NameError(''The algorithm "{algorithm}" you specified is ''
                        ''not a member of "hashlib.algorithms"''.format(algorithm=algorithm))

    hash_algo = hashlib.new(algorithm)  # According to hashlib documentation using new()
                                        # will be slower then calling using named
                                        # constructors, ex.: hashlib.md5()
    with open(path, ''rb'') as f:
        for chunk in iter(lambda: f.read(block_size), b''''):
             hash_algo.update(chunk)
    if human_readable:
        file_hash = hash_algo.hexdigest()
    else:
        file_hash = hash_algo.digest()
    return file_hash

Answer 10

Una solución portátil Python 2/3

Para calcular una suma de comprobación (md5, sha1, etc.), debe abrir el archivo en modo binario, porque sumará los valores de bytes:

Para ser portátil py27 / py3, debe usar los paquetes io , como este:

import hashlib
import io


def md5sum(src):
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        content = fd.read()
        md5.update(content)
    return md5

Si sus archivos son grandes, puede preferir leer el archivo por partes para evitar almacenar todo el contenido del archivo en la memoria:

def md5sum(src, length=io.DEFAULT_BUFFER_SIZE):
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        for chunk in iter(lambda: fd.read(length), b''''):
            md5.update(chunk)
    return md5

El truco aquí es usar la función iter() con un centinela (la cadena vacía).

El iterador creado en este caso llamará a o [la función lambda] sin argumentos para cada llamada a su método next() ; si el valor devuelto es igual a centinela, se StopIteration ; de lo contrario, se devolverá el valor.

Si sus archivos son realmente grandes, es posible que también necesite mostrar información de progreso. Puede hacerlo llamando a una función de devolución de llamada que imprime o registra la cantidad de bytes calculados:

def md5sum(src, callback, length=io.DEFAULT_BUFFER_SIZE):
    calculated = 0
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        for chunk in iter(lambda: fd.read(length), b''''):
            md5.update(chunk)
            calculated += len(chunk)
            callback(calculated)
    return md5

Answer 11

import hashlib,re
opened = open(''/home/parrot/pass.txt'',''r'')
opened = open.readlines()
for i in opened:
    strip1 = i.strip(''/n'')
    hash_object = hashlib.md5(strip1.encode())
    hash2 = hash_object.hexdigest()
    print hash2