In Desarrollo | Última actualizaciónated: Marzo 31, 2023

Cloudways ofrece alojamiento en la nube administrado para empresas de cualquier tamaño para alojar un sitio web o aplicaciones web complejas.

Hashing seguro con Python Hashlib

By Bala Priya C.

Este tutorial te enseñará cómo crearate hashes seguros utilizando la funcionalidad incorporada del módulo hashlib de Python.

Entendidoanding the significance of hashing and how to programmatically calcular hashes seguros puede resultar útil, incluso si no trabaja en seguridad de aplicaciones. ¿Pero por qué?

Bueno, cuando trabaje en proyectos de Python, es probable que se encuentre con casos en los que le preocupe almacenar contraseñas y otra información confidencial en bases de datos o archivos de código fuente. En tales casos, es más seguro ejecutar el algoritmo hash en información confidencial y almacenar el hash en lugar de la información.

En esta guía, cubriremos qué es hash y en qué se diferencia de encryption. También repasaremos las propiedades de las funciones hash seguras. Luego, usaremos algoritmos hash comunes para calcular el hash de texto sin formato en Python. Para hacer esto, usaremos el módulo hashlib incorporado.

Por todo esto y más, ¡comencemos!

¿Qué es el hashing?

El process de hash toma una cadena de mensaje y proporciona una salida de longitud fija llamada hachís. Lo que significa que la longitud del hash de salida para un algoritmo hash determinado es fija, independientemente de la longitud de la entrada. Pero, ¿en qué se diferencia de en?cryption?

en escryption, el mensaje o texto sin formato se cifra mediante un encryption algoritmo que proporciona una salida cifrada. Luego podemos ejecutar el decryption algoritmo en la salida cifrada para recuperar la cadena del mensaje.

Sin embargo, el hashing funciona de manera diferente. Acabamos de enterarnos de que el process de encryption es Invertible en el que puede pasar del mensaje encriptado al mensaje no encriptado y viceversa.

A diferencia de encryption, el hash es no un invertible process, es decir, nosotros no puede ir del hash al mensaje de entrada.

Propiedades de las funciones hash

Repasemos rápidamente algunas propiedades que las funciones hash deberían satisfacer:

Determinista: Las funciones hash son determinista. Dado un mensaje m, el hash de m es siempre el mismo.
Resistente a preimagen: Ya cubrimos esto cuando dijimos que el hash no es una operación invertible. La propiedad de resistencia de preimagen statees que es inviable encontrar el mensaje m del hash de salida.
Resistente a colisiones: Debería ser difícil (o el cálculoally inviable) para encontrar dos cadenas de mensajes diferentes m1 y m2 tal que el hash de m1 es igual al hash de m2. Esta propiedad se llama resistencia a colisiones.
Segunda preimagen resistente: Esto significa dado un mensaje m1 y el hash correspondiente m2, es inviable encontrar otro mensaje m2 tal que hash(m1) = hash(m2).

Módulo hashlib de Python

Python está integrado hashlib El módulo proporciona implementaciones de varios algoritmos hash y resumen de mensajes, incluido el SHA y MD5 algoritmos.

Para usar los constructores y las funciones integradas del módulo hashlib de Python, puede importarlo a su entorno de trabajo de la siguiente manera:

import hashlib

El módulo hashlib proporciona la algorithms_available y algorithms_guaranteed constantes, que denotan el conjunto de algoritmos cuyas implementaciones están disponibles y están garantizadas en un platforma, respectivamente.

Por lo tanto, algorithms_guaranteed es un subconjunto de algorithms_available.

Inicie un REPL de Python, importe hashlib y acceda al algorithms_available y algorithms_guaranteed constantes:

>>> hashlib.algorithms_available

# Output
{'md5', 'md5-sha1', 'sha3_256', 'shake_128', 'sha384', 'sha512_256', 'sha512', 'md4', 
'shake_256', 'whirlpool', 'sha1', 'sha3_512', 'sha3_384', 'sha256', 'ripemd160', 'mdc2', 
'sha512_224', 'blake2s', 'blake2b', 'sha3_224', 'sm3', 'sha224'}

>>> hashlib.algorithms_guaranteed

# Output
{'md5', 'shake_256', 'sha3_256', 'shake_128', 'blake2b', 'sha3_224', 'sha3_384', 
'sha384', 'sha256', 'sha1', 'sha3_512', 'sha512', 'blake2s', 'sha224'}

Vemos eso algorithms_guaranteed es de hecho un subconjunto de algorithms_available

Create Objetos hash en Python

A continuación, aprendamos a crear.ate objetos hash en Python. Calcularemos el hash SHA256 de una cadena de mensaje utilizando los siguientes métodos:

El genérico new() constructor
Constructores específicos de algoritmos

Usando el constructor new()

Vamos a inicializar el message cuerda:

>>> message = "Geekflare is awesome!"

para instantáneamenteate el objeto hash, podemos usar el new() constructor y pase el nombre del algoritmo como se muestra:

>>> sha256_hash = hashlib.new("SHA256")

Ahora podemos llamar a la update() método en el objeto hash con el message cadena como argumento:

>>> sha256_hash.update(message)

Si lo hace, se encontrará con un error, ya que los algoritmos hash solo pueden funcionar con cadenas de bytes.

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Unicode-objects must be encoded before hashing

Para obtener la cadena codificada, puede llamar al encode() método en la cadena de método y luego utilícelo en el update() llamada de método. Después de hacerlo, puede llamar al hexdigest() para obtener el hash sha256 correspondiente a la cadena del mensaje.

sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output:'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

En lugar de codificar la cadena del mensaje usando el encode() método, también puede definirlo como una cadena de bytes prefijando la cadena con b al igual que:

message = b"Geekflare is awesome!"
sha256_hash.update(message)
sha256_hash.hexdigest()
# Output: 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

El hash obtenido es el mismo que prevhash ious, que confirma la naturaleza determinista de las funciones hash.

Además, un pequeño cambio en el message la cadena debería hacer que el hash cambie drásticamenteally (también conocido como “efecto avalancha”).

Para verificar esto, cambiemos la 'a' en 'awesome' a 'A', y calculemos el hash:

message = "Geekflare is Awesome!"
h1 = hashlib.new("SHA256")
h1.update(message.encode())
h1.hexdigest()
# Output: '3c67f334cc598912dc66464f77acb71d88cfd6c8cba8e64a7b749d093c1a53ab'

Vemos que el hash cambia por completo.

Uso del constructor específico del algoritmo

En la previous ejemplo, utilizamos el genérico new() constructor y pasó "SHA256" como el nombre del algoritmo a crearate el objeto hash.

En lugar de hacerlo, también podemos usar el sha256() constructor como se muestra:

sha256_hash = hashlib.sha256()
message= "Geekflare is awesome!"
sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output: 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

El hash de salida es idéntico al hash que obtuvimos anteriormente para el message cadena "Geekflare ¡es increíble!".

Explorando los atributos de los objetos hash

Los objetos hash tienen algunos atributos útiles:

El digest_size El atributo denota el tamaño del resumen en bytes. Por ejemplo, el algoritmo SHA256 devuelve un valor 256-bit hash, que equivale a 32 bytes
El block_size El atributo se refiere al tamaño de bloque utilizado en el algoritmo hash.
El name atributo es el nombre del algoritmo que podemos usar en el new() constructor. Buscar el valor de este atributo puede resultar útil cuando los objetos hash no tienen descriptCinco nombres.

Podemos comprobar estos atributos para el sha256_hash objeto que creamosateD antes:

>>> sha256_hash.digest_size
32
>>> sha256_hash.block_size
64
>>> sha256_hash.name
'sha256'

A continuación, veamos algunas aplicaciones interesantes de hash usando el módulo hashlib de Python.

Ejemplos prácticos de hashing

Verificación de la integridad del software y los archivos

Como desarrolladores, descargamos e instalamos paquetes de software todo el tiempo. Esto es cierto independientemente de si está trabajando en el Distribución de Linux o en un Windows o una Mac.

Sin embargo, algunos mirrors para paquetes de software puede que no sea de confianza. Puede encontrar el hash (o suma de comprobación) junto al enlace de descarga. Y puede verificar la integridad del software descargado calculando el hash y comparándolo con el hash oficial.

Esto también se puede aplicar a los archivos de su máquina. Incluso el cambio más pequeño en el contenido del archivo cambiará drásticamente el hashally, puede verificar si un archivo ha sido modificado verificando el hash.

He aquí un ejemplo sencillo. create un archivo de texto 'my_file.txt' en el directorio de trabajo y agréguele contenido.

$ cat my_file.txt
This is a sample text file.
We are  going to compute the SHA256 hash of this text file and also
check if the file has been modified by
recomputing the hash.

A continuación, puede abrir el archivo en modo binario de lectura ('rb'), lea el contenido del archivo y calcule el hash SHA256 como se muestra:

>>> import hashlib
>>> with open("my_file.txt","rb") as file:
...     file_contents = file.read()
...     sha256_hash = hashlib.sha256()
...     sha256_hash.update(file_contents)
...     original_hash = sha256_hash.hexdigest()

Aquí, la variable original_hash es el hash de 'my_file.txt' en su st actualate.

>>> original_hash
# Output: '53bfd0551dc06c4515069d1f0dc715d002d451c8799add29f3e5b7328fda9f8f'

Ahora modifique el archivo 'my_file.txt'. Puedes quitar el extra espacio en blanco inicial antes de la palabra "ir". 🙂

Calcule el hash una vez más y guárdelo en el computed_hash variable.

>>> import hashlib
>>> with open("my_file.txt","rb") as file:
...     file_contents = file.read()
...     sha256_hash = hashlib.sha256()
...     sha256_hash.update(file_contents)
...     computed_hash = sha256_hash.hexdigest()

A continuación, puede agregar un simple afirmar stateción que afirma si el computed_hash es igual a original_hash.

>>> assert computed_hash == original_hash

Si se modifica el archivo (lo cual es cierto en este caso), debería obtener un AssertionError:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Puede utilizar hash al almacenar información confidencial, como contraseñas en bases de datos. También puede utilizar hash en la autenticación de contraseñas al conectarse a bases de datos. Válidoate el hash de la contraseña ingresada contra el hash de la contraseña correcta.

Para Concluir

Espero que este tutorial te haya ayudado a aprender a generar hashes seguros con Python. Aquí están los puntos clave:

El módulo hashlib de Python proporciona implementaciones listas para usar de varios algoritmos hash. Puede obtener la lista de algoritmos garantizados en su platformulario usando hashlib.algorithms_guaranteed.
para crearate un objeto hash, puedes usar el genérico new() constructor con la sintaxis: hashlib.new("algo-name"). Alternativamente, puede usar los constructores correspondientes a los algoritmos hash específicos, así: hashlib.sha256() para el hash SHA 256.
Después de inicializar la cadena de mensaje que se va a codificar y el objeto hash, puede llamar al update() método en el objeto hash, seguido por el hexdigest() método para obtener el hash.
Hashing puede ser útil para verificar la integridad de los artefactos y archivos de software, almacenar información confidencial en bases de datos y más.

A continuación, aprenda a codificar un Random Password Generator en Python.

Publicado en