<jupyter_start><jupyter_text>hashlib<jupyter_code>import hashlib<jupyter_output><empty_output><jupyter_text>Verificando as possibilidades<jupyter_code>print(hashlib.algorithms_available)
print(hashlib.algorithms_guaranteed)<jupyter_output>{'sha256', 'sha512', 'shake_256', 'sha3_256', 'sha3_224', 'sha1', 'md5', 'shake_128', 'sha224', 'blake2b', 'sha3_512', 'sha384', 'blake2s', 'sha3_384'}<jupyter_text>Entendendo encode()



O método string encode() retorna a versão codificada da string fornecida.

Desde o Python 3.0, as strings são armazenadas como Unicode, ou seja, cada caractere na string é representado por um ponto de código. Portanto, cada string é apenas uma sequência de pontos de código Unicode.

Para armazenamento eficiente dessas strings, a sequência de pontos de código é convertida em um conjunto de bytes. O processo é conhecido como codificação.

Existem várias codificações presentes que tratam uma string de maneira diferente. As codificações populares são utf-8 , ascii , etc.

Usando o encode() método de string , você pode converter strings não codificadas em qualquer codificação compatível com Python . Por padrão, Python usa codificação utf-8.

__Sintax:__

>string.encode(encoding='UTF-8',errors='strict')

errors:

strict - resposta padrão que levanta uma exceção UnicodeDecodeError em caso de falha.

ignore - ignora o unicode não codificado do resultado.

replace - substitui o Unicode não codificado por um ponto de interrogação "?"

xmlcharrefreplace - insere referência de caractere XML em vez de unicode não codificável

backslashreplace - insere uma sequência de escape \ uNNNN em vez de unicode não codificável

namereplace - insere uma sequência de escape \ N {...} em vez de unicode não codificável<jupyter_code># unicode string
string = 'pythön!'

# imprimindo a string e seu tipo
print(f'A string é: {string} e seu tipo é: {type(string)}\n')

# o padrão é utf-8
string_utf = string.encode()

# imprimindo o resultado e seu tipo
print(f'A versão com encode() é: {string_utf}  e seu tipo é: {type(string_utf)}')
# unicode string
string = 'pythön!'

# imprimindo a string e seu tipo
print(f'A string é: {string} e seu tipo é: {type(string)}\n')

# usando o parametro de erro ignore
print(f'A versão com encode("ascii", "ignore") é: {string.encode("ascii", "ignore")}  e seu tipo é: {type(string.encode("ascii", "ignore"))}\n')

# usando o parametro de erro replace
print(f'A versão com encode("ascii", "replace") é: {string.encode("ascii", "replace")}  e seu tipo é: {type(string.encode("ascii", "ignore"))}')<jupyter_output>A string é: pythön! e seu tipo é: <class 'str'>

A versão com encode("ascii", "ignore") é: b'pythn!'  e seu tipo é: <class 'bytes'>

A versão com encode("ascii", "replace") é: b'pyth?n!'  e seu tipo é: <class 'bytes'><jupyter_text>Exemplo para hashlib.sha256<jupyter_code># O hashlib.sha256 usa string "str" codificada em binario e usamos o encode() ou simplesmente colocamos um a frente da string b'string'

# senha do usuário a ser armazenada como hash
senha = 'Ana@2021'
print(f'O tipo da string senha é: {type(senha)}\n')

# transformando string em binario
senha_b = senha.encode()
print(f'O tipo da string senha é: {type(senha_b)}\n')

# se imprimirmos o b estará a frente da string representando a codificação binária
print(f'senha_b é: {senha_b}')

# transformando a senha em hashlib.sha256
sha256 = hashlib.sha256(senha_b)
print(f'sha256 é: {sha256} e seu tipo é: {type(sha256)}\n')

# usamos o .digest() para finalizar o processo
print(f'sha256:\n{sha256.digest()}\ne seu tipo é: {type(sha256)}\n')

# usando .hexdigest() para mostrar a hash em formato hexadeciamal
print(f'sha256:\n{sha256.hexdigest()}\ne seu tipo é: {type(sha256)}\n')<jupyter_output>sha256 é: <sha256 _hashlib.HASH object @ 0x000001B3286F4930> e seu tipo é: <class '_hashlib.HASH'>

sha256:
b"\xfeU\xe9\xb3\xb5V-\x80\x13\n\xfa\xbd\x81\x19\x93y\x8b\t'\x04\x1684\xf5\xed\xd9\xe0h\x85[\x07~"
e seu tipo é: <class '_hashlib.HASH'>

sha256:
fe55e9b3b5562d80130afabd811993798b092704163834f5edd9e068855b077e
e seu tipo é: <class '_hashlib.HASH'><jupyter_text>Exemplo para hashlib.sha256 com .update()

É uma boa pratica anexarmos um token junto a senha do usuário e podemos usar update para atualizar uma senha.<jupyter_code># Criando um token interno para incluir junto a senha
token = '<PASSWORD>'
senha = '<PASSWORD>'
sha256 = hashlib.sha256()

# atualizando sha256 com update()
sha256.update(senha.encode())
# imprimindo somente com senha:
print(f'sha256 somente com senha:\n{sha256.hexdigest()}\n')

# atualizando a senha com token para aumentar a segurança:
sha256.update(token.encode())
# imprimindo somente com senha e token:
print(f'sha256 com senha e token:\n{sha256.hexdigest()}\n')<jupyter_output><PASSWORD>256 somente com senha:
<PASSWORD>

sha256 com senha e token:
<PASSWORD><jupyter_text>Simulando um login<jupyter_code>import hashlib

print(f'{"":=^90}\n{"SIMULANDO UM LOGIN COM hashlib.sha256":^90}\n{"":=^90}')

# Criando uma função para transformar token mais senha em sha256
def criar_senha_sha256(senha):
    token = '<PASSWORD>'
    return hashlib.sha256(str.encode(token+senha)).hexdigest()

# Criando uma função para validar a senha sha256 com a senha digitada
def validar_senha_sha256(senha, senha_sha256):
    if criar_senha_sha256(senha) == senha_sha256:
        return True
    return False

# simulando um banco de dados com usuário e senha e com primeiro usuário admin
senha = criar_senha_sha256('<PASSWORD>')
bd_username_password = {'<PASSWORD>': <PASSWORD>}

# criando menu
menu = int(input('Digite uma opção:\n[1] Cadastrar usuário\n[2] Login\n[3] Sair do programa\n'))

# criando laço de repetição
while menu != 3:

    # cadastrando novo usuário
    if menu == 1:
        new_user = str(input('Digite o nome do usuário: ')).lower().strip()

        # criando um laço de repetição para verificar se o usuário ja esta cadastrado
        while (new_user in bd_username_password) == True:
            new_user = str(input('Este nome de usuário não esta disponivel, digite outro nome do usuário: ')).lower().strip()

        pass_new_user = str(input('Digite a senha: ')).lower().strip()

        # transformando a senha em hash
        pass_new_user = criar_senha_sha256(pass_new_user)
        
        # armazena no banco de dados ficticio
        bd_username_password[new_user]=pass_<PASSWORD>
    
    # fazendo login
    if menu == 2:
        user = str(input('Digite o nome do usuário: ')).lower().strip()
        password = str(input('Digite a senha: ')).lower().strip()
        
        user_true = user in bd_username_password
        if user_true:
            pass_bd = bd_username_password[user]
            validar_pass = validar_senha_sha256(password, pass_bd)
        
        # criando um laço de repetição para verificar se o usuário esta cadastrado e se a senha confere
        while (user_true == False) or (validar_pass == False):

            user = str(input('Dados inexistentes digite o nome e senha do usuário ou exit para sair: ')).lower().strip()

            if user == 'exit':
                break
            else:
                password = str(input('Digite a senha: ')).lower().strip()
                user_true = user in bd_username_password
                if user_true:
                    pass_bd = bd_username_password[user]
                    validar_pass = validar_senha_sha256(password, pass_bd)
            
            print(f'user_true = {user_true}\nvalidar_pas = {validar_pass}')
            
        if (user_true == True) or (validar_pass == True):
            print(f'{user} seja bem vindo!\n')
        
    menu = int(input('Digite uma opção:\n[1] Cadastrar usuário\n[2] Login\n[3] Sair do programa\n'))

# imprimindo o banco de dados ficticio com os usuários e senha
for usuario, senha in bd_username_password.items():
    print(f'Usuário: {usuario}\nSenha: {senha}\n')<jupyter_output>==========================================================================================
                          SIMULANDO UM LOGIN COM hashlib.sha256                           
==========================================================================================
livio seja bem vindo!

user_true = True
validar_pas = True
flavia seja bem vindo!

Usuário: admin
Senha: <PASSWORD>

Usuário: livio
Senha: <PASSWORD>

Usuário: flavia
Senha: <PASSWORD><jupyter_text>bcrypt - library<jupyter_code>import bcrypt

senha = b'admin'

# criando salt
salt = bcrypt.gensalt()

# gerando hash
hashed = bcrypt.hashpw(senha, salt)
print(hashed) # hash em binário
print(hashed.decode())# hash decode

# conferindo hash iguais
if bcrypt.checkpw(b'admin', hashed):
    print('OK!!!')
else:
    print('Hash diferente!!!')
    
# simulando falha
if bcrypt.checkpw(b'adminnn', hashed):
    print('OK!!!')
else:
    print('Hash diferente!!!')<jupyter_output>b'$2b$12$1bemRBkyVi8CetHW3MytI.VugDol.bBZ/TL/MWPrznqeSqwhs83XK'
$2b$12$1bemRBkyVi8CetHW3MytI.VugDol.bBZ/TL/MWPrznqeSqwhs83XK
OK!!!
Hash diferente!!!
{'fraction_non_alphanumeric': 0.1278154384430352, 'fraction_numerical': 0.03258254974852395, 'mean_word_length': 3.894060995184591, 'pattern_counts': {'":': 3, '<': 43, '<?xml version=': 0, '>': 44, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 1}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '407771', 'license': 'MIT', 'n_tokens_mistral': 3482, 'n_tokens_neox': 3220, 'n_words': 908, 'path': 'hashlib.ipynb', 'repo_name': 'LivioAlvarenga/hashlib_library', 'size': '9404'}