Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF for Python
  2. Blog do IronPDF for Python
  3. Ajuda do Python
  4. hashlib Python
AJUDA DO PYTHON

hashlib Python (Como funciona: um guia para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

O módulo hashlib em Python é uma ferramenta poderosa para trabalhar com algoritmos seguros de hash e resumo de mensagens. Este módulo fornece uma interface padrão para muitos algoritmos de hash seguros, tornando-o uma escolha versátil para desenvolvedores que precisam garantir a integridade e a segurança dos dados. Mais adiante neste artigo, também analisaremos uma biblioteca versátil para geração de PDFs da IronSoftware, chamada IronPDF , e escreveremos um script usando ambas as bibliotecas para demonstrar sua utilização.

O módulo hashlib faz parte da biblioteca padrão do Python, portanto não é necessário instalá-lo separadamente. Inclui diversas funções de hash criptográficas, como MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 e a série SHA-3. Essas funções são usadas para criar objetos hash, que podem então ser usados ​​para gerar hashes de dados.

Principais características

  1. Ampla gama de algoritmos: o hashlib suporta vários algoritmos de hash, incluindo alguns mais antigos como MD5 e SHA-1 e outros mais modernos como SHA-256 e SHA-3.
  2. Interface simples: Cada algoritmo de hash possui um método construtor que retorna um objeto hash. Este objeto pode ser alimentado com dados usando o método update e produzir o valor de hash usando os métodos digest ou hexdigest.
  3. Segurança: Embora alguns algoritmos como MD5 e SHA-1 tenham vulnerabilidades conhecidas, o hashlib inclui opções mais seguras como SHA-256 e SHA-3.

Instalação

O hashlib é um módulo integrado e não requer instalação explícita.

Uso básico

Aqui está um exemplo simples de como usar o hashlib para gerar um hash SHA-256 usando o construtor de hash do 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

Recursos avançados

  • Suporte a multithreading: Com a função de hash criptográfica, o hashlib libera o Global Interpreter Lock (GIL) durante o cálculo do hash se mais de 2047 bytes de dados forem fornecidos de uma só vez, permitindo melhor desempenho em aplicações multithread.
  • Algoritmos de hash personalizados: Se a biblioteca hashlib da sua distribuição Python estiver vinculada a uma versão do OpenSSL que fornece algoritmos adicionais, você pode acessá-los através do método new().

Vários tipos de hashing usando o módulo HashLib

1. Hashing simples

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

O código gera um hash SHA-256 para os dados de entrada.

2. Utilizando diferentes tamanhos de digestão.

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

O código gera hashes para MD5, SHA-256 e SHA-512 usando os dados fornecidos.

3. Hashing com Chave

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 demonstra a criação de um hash com chave usando o algoritmo Blake2b.

4. Hashing Aleatório

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

Esses exemplos abrangem o hashing básico usando diferentes tamanhos de resumo. Ajustes podem ser feitos com base em requisitos ou preferências específicas, como o uso de diferentes algoritmos ou parâmetros.

Aplicações práticas

  1. Integridade dos dados: As funções hash são geralmente usadas para confirmar a integridade dos registros. Comparando o hash dos dados originais com o hash dos dados recebidos, você pode garantir que os dados não foram alterados.
  2. Armazenamento de senhas: Funções hash são frequentemente usadas para armazenar senhas com segurança. O sistema armazena o hash da senha em vez da senha propriamente dita. Quando um usuário faz login, o hash da senha digitada é comparado com o hash armazenado.
  3. Assinaturas digitais: Funções hash são comumente usadas para criar assinaturas digitais, que verificam a autenticidade e a integridade de uma mensagem.

Apresentando o IronPDF

hashlib Python ((Como funciona: um guia para desenvolvedores)): Figura 1 - IronPDF for Python: a biblioteca PDF for Python

IronPDF é uma poderosa biblioteca Python para criar, editar e assinar PDFs usando HTML, CSS, imagens e JavaScript. Oferece recursos de alto desempenho com uso mínimo de memória. Os usuários podem gerar PDFs a partir de HTML , mesclar ou dividir documentos PDF, extrair texto e imagens de PDFs , aplicar marcas d'água , rasterizar um PDF para formatos de imagem como JPEG e PNG, criptografar arquivos PDF e muito mais. O IronPDF oferece uma ampla gama de operações com PDFs.

Principais características do IronPDF

Conversão de HTML para PDF

Os usuários podem converter arquivos HTML, strings HTML e URLs em PDFs. Por exemplo, renderize uma página da web como um PDF usando o renderizador de PDF para Chrome do IronPDF.

Suporte multiplataforma

O IronPDF foi projetado para versões do Python 3 ou superiores e funciona em plataformas Windows, Mac, Linux ou na nuvem.

O IronPDF também está disponível em .NET , Java , Python e Node.js

Edição e assinatura

O usuário pode definir propriedades, adicionar segurança com senhas e permissões e aplicar assinaturas digitais a PDFs usando o IronPDF.

Modelos de página e configurações

O IronPDF permite personalizar documentos PDF com cabeçalhos, rodapés, números de página e margens ajustáveis. Também oferece suporte a layouts responsivos e tamanhos de papel personalizados.

Conformidade com as normas

O pacote IronPDF também está em conformidade com os padrões PDF, como PDF/A e PDF/UA. Suporta codificação de caracteres UTF-8 e lida com recursos como imagens, CSS e fontes.

Gere documentos PDF usando o IronPDF e o módulo HashLib.

Pré-requisitos do IronPDF

  1. O IronPDF utiliza o .NET 6.0 como tecnologia subjacente. Portanto, certifique-se de que o runtime do .NET 6.0 esteja instalado em seu sistema.
  2. Python 3.0+: Você precisa ter o Python versão 3 ou posterior instalado.
  3. Pip: Instale o instalador de pacotes Python pip para instalar o pacote IronPDF .

Para começar, vamos criar um arquivo Python para adicionar nossos scripts. Neste exemplo, usaremos o Visual Studio Code como editor de código.

Abra o Visual Studio Code e crie um arquivo chamado hashlibDemo.py.

Instale a biblioteca IronPDF :

pip install ironpdf

Em seguida, adicione o código abaixo para demonstrar o uso dos pacotes Python IronPDF e 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

Explicação do código

O código fornecido demonstra o uso de várias técnicas de hashing utilizando a biblioteca hashlib do Python:

  1. Exemplo simples de hashing: Calcula o hash SHA-256 de uma string de dados específica (b'IronPDF from Iron Software is Awesome').
  2. Hashing com diferentes tamanhos de resumo: Esta seção demonstra o uso dos algoritmos MD5, SHA-256 e SHA-512 para gerar hashes na mesma sequência de dados.
  3. Exemplo de hash com chave: Este exemplo usa a função de hash blake2b com uma chave especificada (b'pseudorandom key') para realizar o hash com chave nos dados.
  4. Exemplo de Hashing Aleatório: Utiliza o algoritmo PBKDF2-HMAC com SHA-256 para gerar um hash aleatório com um salt gerado aleatoriamente.
  5. Geração de PDF: Após demonstrar os exemplos de hashing, o código gera um documento PDF usando o IronPDF, que inclui o conteúdo HTML que exibe os exemplos de hashing.

Cada exemplo ilustra diferentes aspectos do hashing criptográfico, como hashing padrão, hashing com chave e técnicas de hashing aleatório.

Saída

hashlib Python ((Como funciona: um guia para desenvolvedores)): Figura 2 - Exemplo de saída do console

PDF

hashlib Python ((Como funciona: um guia para desenvolvedores)): Figura 3 - Exemplo de saída em PDF usando IronPDF

Licença IronPDF

hashlib Python ((Como funciona: um guia para desenvolvedores)): Figura 4 - Página de licenciamento do IronPDF

O IronPDF funciona com a chave de licença do Python. O IronPDF for Python oferece uma chave de licença de avaliação gratuita para permitir que os usuários testem seus diversos recursos antes da compra.

Insira a chave de licença no início do script antes de usar o pacote IronPDF :

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

Conclusão

O módulo hashlib é essencial para a biblioteca padrão do Python, fornecendo funções hash robustas e seguras para diversas aplicações. Seja para garantir a integridade dos dados, armazenar senhas com segurança ou criar assinaturas digitais, o hashlib oferece as ferramentas necessárias. Por outro lado, o IronPDF é uma biblioteca poderosa para geração e manipulação de PDFs. Com essas duas bibliotecas, os desenvolvedores podem gerar hashes rapidamente e armazená-los em formato PDF.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim