Ícono de mensaje
Saltar al pie de página
  1. IronPDF for Python
  2. Blog de IronPDF for Python
  3. Ayuda de Python
  4. hashlib Python
AYUDA DE PYTHON

hashlib Python (Cómo Funciona: Una Guía para Desarrolladores)

Curtis Chau
Curtis Chau
Actualizado:

El módulo hashlib en Python es una herramienta poderosa para trabajar con algoritmos de hash seguro y digestión de mensajes. Este módulo proporciona una interfaz estándar para muchos algoritmos de hash seguro, lo que lo convierte en una opción versátil para los desarrolladores que necesitan asegurar la integridad y seguridad de los datos. Más adelante en el artículo, también exploraremos una biblioteca versátil de generación de PDF de Iron Software llamada IronPDF y escribiremos un script usando ambas bibliotecas para demostrar su uso.

El módulo hashlib es parte de la biblioteca estándar de Python, por lo que no es necesario instalarlo por separado. Incluye varias funciones hash criptográficas, como MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 y la serie SHA-3. Estas funciones se utilizan para crear objetos hash, que luego se pueden utilizar para generar hashes de datos.

Características clave

  1. Amplia Gama de Algoritmos: hashlib admite múltiples algoritmos de hash, incluidos los más antiguos como MD5 y SHA-1 y más modernos como SHA-256 y SHA-3.
  2. Interfaz Simple: Cada algoritmo de hash tiene un método de constructor que devuelve un objeto hash. Este objeto se puede alimentar con datos usando el método update y producir el valor hash usando los métodos digest o hexdigest.
  3. Seguridad: Aunque algunos algoritmos como MD5 y SHA-1 tienen vulnerabilidades conocidas, hashlib incluye opciones más seguras como SHA-256 y SHA-3.

Instalación

hashlib es un módulo incorporado y no requiere instalación explícita.

Uso básico

Aquí hay un ejemplo simple de cómo usar hashlib para generar un hash SHA-256 usando el constructor hash de hashlib:

import hashlib

# Creating hash objects with SHA-256
hash_object = hashlib.sha256()
# Update the hash object with data
hash_object.update(b'IronPDF from Iron Software is Awesome')
# Get the hexadecimal representation of the hash
hash_hex = hash_object.hexdigest()  # hash_hex is the hexadecimal digest
print(hash_hex)  # Output the hash
# Output: 6fc0c7d6af8eb51f0cd89281db55c6a6b76b5310226fa5af2272a8eb42cc1bfe
import hashlib

# Creating hash objects with SHA-256
hash_object = hashlib.sha256()
# Update the hash object with data
hash_object.update(b'IronPDF from Iron Software is Awesome')
# Get the hexadecimal representation of the hash
hash_hex = hash_object.hexdigest()  # hash_hex is the hexadecimal digest
print(hash_hex)  # Output the hash
# Output: 6fc0c7d6af8eb51f0cd89281db55c6a6b76b5310226fa5af2272a8eb42cc1bfe
PYTHON

Características avanzadas

  • Soporte para Multihilos: Con la función de hash criptográfico, hashlib libera el Global Interpreter Lock (GIL) mientras calcula un hash si se suministran más de 2047 bytes de datos a la vez, permitiendo un mejor rendimiento en aplicaciones multihilo.
  • Algoritmos de Hash Personalizados: Si la distribución de hashlib en Python está vinculada a una compilación de OpenSSL que proporciona algoritmos adicionales, puede acceder a ellos a través del método new().

Varios tipos de Hashing utilizando el módulo HashLib

1. Hashing simple

import hashlib

# Simple hashing example
data = b'Hello, World!'
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print("SHA-256 Hash:", hex_dig)
# Output: SHA-256 Hash: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
import hashlib

# Simple hashing example
data = b'Hello, World!'
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print("SHA-256 Hash:", hex_dig)
# Output: SHA-256 Hash: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
PYTHON

El código genera un hash SHA-256 para los datos de entrada.

2. Uso de diferentes tamaños de compilación

import hashlib

# Hashing with different digest sizes
data = b'Hello, World!'

# MD5, SHA-256, and SHA-512 hash generation
hash_md5 = hashlib.md5(data).hexdigest()
hash_sha256 = hashlib.sha256(data).hexdigest()
hash_sha512 = hashlib.sha512(data).hexdigest()

# Print each hash
print("MD5 Hash (hex):", hash_md5)
print("SHA-256 Hash (hex):", hash_sha256)
print("SHA-512 Hash (hex):", hash_sha512)
# Output:
# MD5 Hash (hex): 65a8e27d8879283831b664bd8b7f0ad4
# SHA-256 Hash (hex): dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
# SHA-512 Hash (hex): 374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387
import hashlib

# Hashing with different digest sizes
data = b'Hello, World!'

# MD5, SHA-256, and SHA-512 hash generation
hash_md5 = hashlib.md5(data).hexdigest()
hash_sha256 = hashlib.sha256(data).hexdigest()
hash_sha512 = hashlib.sha512(data).hexdigest()

# Print each hash
print("MD5 Hash (hex):", hash_md5)
print("SHA-256 Hash (hex):", hash_sha256)
print("SHA-512 Hash (hex):", hash_sha512)
# Output:
# MD5 Hash (hex): 65a8e27d8879283831b664bd8b7f0ad4
# SHA-256 Hash (hex): dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
# SHA-512 Hash (hex): 374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387
PYTHON

El código genera hashes para MD5, SHA-256 y SHA-512 usando los datos proporcionados.

3. Cifrado con clave

import hashlib
from hashlib import blake2b

# Keyed hashing example
h = blake2b(key=b'pseudorandom key', digest_size=16)
h.update(b'message data')
print(h.hexdigest())
# Output: 3d363ff7401e02026f4a4687d4863ced
import hashlib
from hashlib import blake2b

# Keyed hashing example
h = blake2b(key=b'pseudorandom key', digest_size=16)
h.update(b'message data')
print(h.hexdigest())
# Output: 3d363ff7401e02026f4a4687d4863ced
PYTHON

Este código demuestra la creación de un hash con clave utilizando el algoritmo Blake2b.

4. Hashing aleatorio

import hashlib
import os

# Randomized hashing example using PBKDF2-HMAC
data = b'Hello, World!'
salt = os.urandom(16)  # Generate a random salt
hash_object = hashlib.pbkdf2_hmac('sha256', data, salt, 100000)
hex_dig = hash_object.hex()
print("Randomized Hash (SHA-256):", hex_dig)
# Output: Randomized Hash (SHA-256): a2a3c1a30a2add1867d55eac97fd9c84dc679691c0f15ae09c01e1bcc63ba47a
import hashlib
import os

# Randomized hashing example using PBKDF2-HMAC
data = b'Hello, World!'
salt = os.urandom(16)  # Generate a random salt
hash_object = hashlib.pbkdf2_hmac('sha256', data, salt, 100000)
hex_dig = hash_object.hex()
print("Randomized Hash (SHA-256):", hex_dig)
# Output: Randomized Hash (SHA-256): a2a3c1a30a2add1867d55eac97fd9c84dc679691c0f15ae09c01e1bcc63ba47a
PYTHON

Estos ejemplos cubren hashing básico utilizando diferentes tamaños de digestión. Se pueden hacer ajustes según requisitos o preferencias específicas, como usar diferentes algoritmos o parámetros.

Aplicaciones prácticas

  1. Integridad de Datos: Las funciones de hash generalmente se utilizan para confirmar la integridad de los registros. Al comparar el hash de los datos originales con el hash de los datos recibidos, puede asegurarse de que los datos no han sido alterados.
  2. Almacenamiento de Contraseñas: Las funciones de hash a menudo se usan para almacenar contraseñas de manera segura. El sistema almacena el hash de la contraseña en lugar de la contraseña real. Cuando un usuario inicia sesión, el hash de la contraseña ingresada se compara con el hash almacenado.
  3. Firmas Digitales: Las funciones de hash se utilizan comúnmente para crear firmas digitales, que verifican la autenticidad e integridad de un mensaje.

Presentando IronPDF

hashlib Python ((Cómo Funciona: Una Guía para Desarrolladores)): Figura 1 - IronPDF para Python: La Biblioteca Python PDF

IronPDF es una poderosa biblioteca Python para crear, editar y firmar PDFs usando HTML, CSS, imágenes y JavaScript. Proporciona capacidades de alto rendimiento con un uso mínimo de memoria. Los usuarios pueden generar PDFs desde HTML, fusionar o dividir documentos PDF, extraer texto e imágenes de PDFs, aplicar marcas de agua, rasterizar un PDF a formatos de imagen como JPEG y PNG, encriptar archivos PDF y más. IronPDF ofrece una amplia gama de operaciones PDF.

Características principales de IronPDF

Conversión de HTML a PDF

Los usuarios pueden convertir archivos HTML, cadenas HTML y URLs a PDFs. Por ejemplo, renderizar una página web como un PDF usando el renderizador PDF de Chrome de IronPDF.

Soporte multiplataforma

IronPDF está diseñado para versiones de Python 3+ y se ejecuta en Windows, Mac, Linux o plataformas en la nube.

IronPDF también está disponible en .NET, Java, Python y Node.js.

Edición y firma

El usuario puede establecer propiedades, agregar seguridad con contraseñas y permisos, y aplicar firmas digitales a PDFs usando IronPDF.

Plantillas de página y configuración

IronPDF permite personalizar documentos PDF con encabezados, pies de página, números de página y márgenes ajustables. También admite diseños responsivos y tamaños de papel personalizados.

Cumplimiento de normas

El paquete IronPDF también se adhiere a los estándares PDF como PDF/A y PDF/UA. Admite codificación de caracteres UTF-8 y maneja recursos como imágenes, CSS y fuentes.

Generar documentos PDF con IronPDF y el módulo HashLib

Requisitos previos para IronPDF

  1. IronPDF usa .NET 6.0 como su tecnología subyacente. Por lo tanto, asegúrese de que el runtime .NET 6.0 esté instalado en su sistema.
  2. Python 3.0+: Necesita tener instalada la versión 3 o posterior de Python.
  3. Pip: Instale el instalador de paquetes de Python pip para instalar el paquete IronPDF.

Para comenzar, vamos a crear un archivo Python para agregar nuestros scripts. Para este ejemplo, usamos Visual Studio Code como el editor de código.

Abra Visual Studio Code y cree un archivo, hashlibDemo.py.

Instale la biblioteca de IronPDF:

 pip install ironpdf

Luego agregue el siguiente código para demostrar el uso de los paquetes de Python IronPDF y Hashlib

import hashlib
import os
from hashlib import blake2b
from ironpdf import *

# Apply your license key
License.LicenseKey = "your key"

# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with hashlib</h1>"
content += "<p>Data for all the below examples = IronPDF from Iron Software is Awesome</p>"
content += "<h2> Simple hashing example</h2>"

# Simple hashing example
data = b'IronPDF from Iron Software is Awesome'
content += "<p>hashlib.sha256(data)</p>"
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print("SHA-256 Hash:", hex_dig)
content += "<p>SHA-256 Hash:"+str(hex_dig)+"</p>"

content += "<h2> Hashing with different digest sizes</h2>"
# Hashing with different digest sizes
hash_md5 = hashlib.md5(data).hexdigest()
content += "<p>hashlib.md5(data).hexdigest()</p>"
hash_sha256 = hashlib.sha256(data).hexdigest()
content += "<p>hashlib.sha256(data).hexdigest()</p>"
hash_sha512 = hashlib.sha512(data).hexdigest()
content += "<p>hashlib.sha512(data).hexdigest()</p>"

print("MD5 Hash (hex):", hash_md5)
print("SHA-256 Hash (hex):", hash_sha256)
print("SHA-512 Hash (hex):", hash_sha512)
content += "<p>MD5 Hash (hex):"+str(hash_md5)+"</p>"
content += "<p>SHA-256 Hash (hex):"+str(hash_sha256)+"</p>"
content += "<p>SHA-512 Hash (hex):"+str(hash_sha512)+"</p>"

# Keyed hashing example
content += "<h2> Keyed hashing example</h2>"
h = blake2b(key=b'pseudorandom key', digest_size=16)
content += "<p></p>"
h.update(data)
print(h.hexdigest())
content += "<p>Keyed Hash (hex):"+str(h.hexdigest())+"</p>"

# Randomized hashing example 
content += "<h2> Randomized hashing example </h2>"
salt = os.urandom(16)  # Generate a random salt
hash_object = hashlib.pbkdf2_hmac('sha256', data, salt, 100000)
content += "<p>hashlib.pbkdf2_hmac('sha256', data, salt, 100000)</p>"
hex_dig = hash_object.hex()
print("Randomized Hash (SHA-256):", hex_dig)
content += "<p>Randomized Hash (SHA-256):"+str(hex_dig)+"</p>"

# Generate PDF using IronPDF
renderer = ChromePdfRenderer()
pdf = renderer.RenderHtmlAsPdf(content)
# Export to a file or Stream
pdf.SaveAs("Demo-hashlib.pdf")
import hashlib
import os
from hashlib import blake2b
from ironpdf import *

# Apply your license key
License.LicenseKey = "your key"

# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with hashlib</h1>"
content += "<p>Data for all the below examples = IronPDF from Iron Software is Awesome</p>"
content += "<h2> Simple hashing example</h2>"

# Simple hashing example
data = b'IronPDF from Iron Software is Awesome'
content += "<p>hashlib.sha256(data)</p>"
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print("SHA-256 Hash:", hex_dig)
content += "<p>SHA-256 Hash:"+str(hex_dig)+"</p>"

content += "<h2> Hashing with different digest sizes</h2>"
# Hashing with different digest sizes
hash_md5 = hashlib.md5(data).hexdigest()
content += "<p>hashlib.md5(data).hexdigest()</p>"
hash_sha256 = hashlib.sha256(data).hexdigest()
content += "<p>hashlib.sha256(data).hexdigest()</p>"
hash_sha512 = hashlib.sha512(data).hexdigest()
content += "<p>hashlib.sha512(data).hexdigest()</p>"

print("MD5 Hash (hex):", hash_md5)
print("SHA-256 Hash (hex):", hash_sha256)
print("SHA-512 Hash (hex):", hash_sha512)
content += "<p>MD5 Hash (hex):"+str(hash_md5)+"</p>"
content += "<p>SHA-256 Hash (hex):"+str(hash_sha256)+"</p>"
content += "<p>SHA-512 Hash (hex):"+str(hash_sha512)+"</p>"

# Keyed hashing example
content += "<h2> Keyed hashing example</h2>"
h = blake2b(key=b'pseudorandom key', digest_size=16)
content += "<p></p>"
h.update(data)
print(h.hexdigest())
content += "<p>Keyed Hash (hex):"+str(h.hexdigest())+"</p>"

# Randomized hashing example 
content += "<h2> Randomized hashing example </h2>"
salt = os.urandom(16)  # Generate a random salt
hash_object = hashlib.pbkdf2_hmac('sha256', data, salt, 100000)
content += "<p>hashlib.pbkdf2_hmac('sha256', data, salt, 100000)</p>"
hex_dig = hash_object.hex()
print("Randomized Hash (SHA-256):", hex_dig)
content += "<p>Randomized Hash (SHA-256):"+str(hex_dig)+"</p>"

# Generate PDF using IronPDF
renderer = ChromePdfRenderer()
pdf = renderer.RenderHtmlAsPdf(content)
# Export to a file or Stream
pdf.SaveAs("Demo-hashlib.pdf")
PYTHON

Explicación del código

El código proporcionado muestra el uso de varias técnicas de hashing usando la biblioteca hashlib de Python:

  1. Ejemplo de Hashing Simple: Calcula el hash SHA-256 de una cadena de datos específica (b'IronPDF from Iron Software is Awesome').
  2. Hashing con Diferentes Tamaños de Digestión: Esta sección demuestra el hashing usando los algoritmos MD5, SHA-256 y SHA-512 en la misma cadena de datos.
  3. Ejemplo de Hashing con Clave: Este ejemplo utiliza la función de hash blake2b con una clave especificada (b'pseudorandom key') para realizar hashing con clave en los datos.
  4. Ejemplo de Hashing Aleatorio: Utiliza el algoritmo PBKDF2-HMAC con SHA-256 para generar un hash aleatorio con una sal generada aleatoriamente.
  5. Generación de PDF: Después de demostrar los ejemplos de hashing, el código genera un documento PDF usando IronPDF, que incluye el contenido HTML que muestra los ejemplos de hashing.

Cada ejemplo ilustra diferentes aspectos del hashing criptográfico, como el hashing estándar, el hashing con clave y las técnicas de hashing aleatorio.

Resultado

hashlib Python ((Cómo Funciona: Una Guía para Desarrolladores)): Figura 2 - Ejemplo de salida de consola

PDF

hashlib Python ((Cómo Funciona: Una Guía para Desarrolladores)): Figura 3 - Ejemplo de salida PDF usando IronPDF

Licencia de IronPDF

hashlib Python ((Cómo Funciona: Una Guía para Desarrolladores)): Figura 4 - Página de licencias de IronPDF

IronPDF se ejecuta con la clave de licencia de Python. IronPDF para Python ofrece una clave de licencia de prueba gratuita para permitir a los usuarios probar sus amplias características antes de la compra.

Coloca la clave de licencia al inicio del script antes de usar el paquete IronPDF:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
PYTHON

Conclusión

El módulo hashlib es esencial para la biblioteca estándar de Python, proporcionando funciones de hash robustas y seguras para diversas aplicaciones. Ya sea que esté asegurando la integridad de los datos, almacenando contraseñas de manera segura o creando firmas digitales, hashlib ofrece las herramientas necesarias. Por otro lado, IronPDF es una poderosa biblioteca de generación y manipulación de PDF. Con ambas bibliotecas, los desarrolladores pueden generar rápidamente hashes y almacenarlos en formato PDF.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita