must - python md5 file

Implementación de SHA-256 en Python

Question

Estoy buscando una implementación de la función hash SHA-256 escrita en Python. Quiero usarlo para comprender mejor cómo funciona la función SHA-256, y creo que Python es el lenguaje ideal para esto. El pseudo-código tiene la limitación de que no puedo ejecutarlo / probarlo, para ver qué hacen mis modificaciones del código a la salida.

Answer 1

La fuente de PyPy contiene una implementación de Python puro de SHA-256 here . Hurgando en ese directorio, es probable que también encuentre implementaciones de python puro de otros hashes estándar.

Answer 2

Si solo quieres el valor hash:

from hashlib import sha256
data=input(''Enter plaintext data: '')
output=sha256(data.encode(''utf-8''))
print(output)

El hashlib de Python también tiene funciones de hash SHA-1, SHA-384, SHA-512 y MD5.

Answer 3

Traducir http://en.wikipedia.org/wiki/SHA-2#SHA-256_.28a_SHA-2_variant.29_pseudocode a Python debe ser sencillo.

Answer 4

initial_hash_values=[
''6a09e667'',''bb67ae85'',''3c6ef372'',''a54ff53a'',
''510e527f'',''9b05688c'',''1f83d9ab'',''5be0cd19''
]

sha_256_constants=[
''428a2f98'',''71374491'',''b5c0fbcf'',''e9b5dba5'',
''3956c25b'',''59f111f1'',''923f82a4'',''ab1c5ed5'',
''d807aa98'',''12835b01'',''243185be'',''550c7dc3'',
''72be5d74'',''80deb1fe'',''9bdc06a7'',''c19bf174'',
''e49b69c1'',''efbe4786'',''0fc19dc6'',''240ca1cc'',
''2de92c6f'',''4a7484aa'',''5cb0a9dc'',''76f988da'',
''983e5152'',''a831c66d'',''b00327c8'',''bf597fc7'',
''c6e00bf3'',''d5a79147'',''06ca6351'',''14292967'',
''27b70a85'',''2e1b2138'',''4d2c6dfc'',''53380d13'',
''650a7354'',''766a0abb'',''81c2c92e'',''92722c85'',
''a2bfe8a1'',''a81a664b'',''c24b8b70'',''c76c51a3'',
''d192e819'',''d6990624'',''f40e3585'',''106aa070'',
''19a4c116'',''1e376c08'',''2748774c'',''34b0bcb5'',
''391c0cb3'',''4ed8aa4a'',''5b9cca4f'',''682e6ff3'',
''748f82ee'',''78a5636f'',''84c87814'',''8cc70208'',
''90befffa'',''a4506ceb'',''bef9a3f7'',''c67178f2''
]

def bin_return(dec):
    return(str(format(dec,''b'')))

def bin_8bit(dec):
    return(str(format(dec,''08b'')))

def bin_32bit(dec):
    return(str(format(dec,''032b'')))

def bin_64bit(dec):
    return(str(format(dec,''064b'')))

def hex_return(dec):
    return(str(format(dec,''x'')))

def dec_return_bin(bin_string):
    return(int(bin_string,2))

def dec_return_hex(hex_string):
    return(int(hex_string,16))

def L_P(SET,n):
    to_return=[]
    j=0
    k=n
    while k<len(SET)+1:
        to_return.append(SET[j:k])
        j=k
        k+=n 
    return(to_return)

def s_l(bit_string):
    bit_list=[]
    for i in range(len(bit_string)):
        bit_list.append(bit_string[i])
    return(bit_list)

def l_s(bit_list):
    bit_string=''''
    for i in range(len(bit_list)):
        bit_string+=bit_list[i]
    return(bit_string)

def rotate_right(bit_string,n):
    bit_list = s_l(bit_string)
    count=0
    while count <= n-1:
        list_main=list(bit_list)
        var_0=list_main.pop(-1)
        list_main=list([var_0]+list_main)
        bit_list=list(list_main)
        count+=1
    return(l_s(list_main))

def shift_right(bit_string,n):
    bit_list=s_l(bit_string)
    count=0
    while count <= n-1:
        bit_list.pop(-1)
        count+=1
    front_append=[''0'']*n
    return(l_s(front_append+bit_list))

def mod_32_addition(input_set):
    value=0
    for i in range(len(input_set)):
        value+=input_set[i]
    mod_32 = 4294967296
    return(value%mod_32)

def xor_2str(bit_string_1,bit_string_2):
    xor_list=[]
    for i in range(len(bit_string_1)):
        if bit_string_1[i]==''0'' and bit_string_2[i]==''0'':
            xor_list.append(''0'')
        if bit_string_1[i]==''1'' and bit_string_2[i]==''1'':
            xor_list.append(''0'')
        if bit_string_1[i]==''0'' and bit_string_2[i]==''1'':
            xor_list.append(''1'')
        if bit_string_1[i]==''1'' and bit_string_2[i]==''0'':
            xor_list.append(''1'')
    return(l_s(xor_list))

def and_2str(bit_string_1,bit_string_2):
    and_list=[]
    for i in range(len(bit_string_1)):
        if bit_string_1[i]==''1'' and bit_string_2[i]==''1'':
            and_list.append(''1'')
        else:
            and_list.append(''0'')

    return(l_s(and_list))

def or_2str(bit_string_1,bit_string_2):
    or_list=[]
    for i in range(len(bit_string_1)):
        if bit_string_1[i]==''0'' and bit_string_2[i]==''0'':
            or_list.append(''0'')
        else:
            or_list.append(''1'')
    return(l_s(or_list))

def not_str(bit_string):
    not_list=[]
    for i in range(len(bit_string)):
        if bit_string[i]==''0'':
            not_list.append(''1'')
        else:
            not_list.append(''0'')
    return(l_s(not_list))

''''''
SHA-256 Specific Functions:
''''''

def Ch(x,y,z):
    return(xor_2str(and_2str(x,y),and_2str(not_str(x),z)))

def Maj(x,y,z):
    return(xor_2str(xor_2str(and_2str(x,y),and_2str(x,z)),and_2str(y,z)))

def e_0(x):
    return(xor_2str(xor_2str(rotate_right(x,2),rotate_right(x,13)),rotate_right(x,22)))

def e_1(x):
    return(xor_2str(xor_2str(rotate_right(x,6),rotate_right(x,11)),rotate_right(x,25)))

def s_0(x):
    return(xor_2str(xor_2str(rotate_right(x,7),rotate_right(x,18)),shift_right(x,3)))

def s_1(x):
    return(xor_2str(xor_2str(rotate_right(x,17),rotate_right(x,19)),shift_right(x,10)))

def message_pad(bit_list):
    pad_one = bit_list + ''1''
    pad_len = len(pad_one)
    k=0
    while ((pad_len+k)-448)%512 != 0:
        k+=1
    back_append_0 = ''0''*k
    back_append_1 = bin_64bit(len(bit_list))
    return(pad_one+back_append_0+back_append_1)

def message_bit_return(string_input):
    bit_list=[]
    for i in range(len(string_input)):
        bit_list.append(bin_8bit(ord(string_input[i])))
    return(l_s(bit_list))

def message_pre_pro(input_string):
    bit_main = message_bit_return(input_string)
    return(message_pad(bit_main))

def message_parsing(input_string):
    return(L_P(message_pre_pro(input_string),32))

def message_schedule(index,w_t):
    new_word = bin_32bit(mod_32_addition([int(s_1(w_t[index-2]),2),int(w_t[index-7],2),int(s_0(w_t[index-15]),2),int(w_t[index-16],2)]))
    return(new_word)

''''''
This example of SHA_256 works for an input string <56 characters.
''''''

def sha_256(input_string):
    w_t=message_parsing(input_string)
    a=bin_32bit(dec_return_hex(initial_hash_values[0]))
    b=bin_32bit(dec_return_hex(initial_hash_values[1]))
    c=bin_32bit(dec_return_hex(initial_hash_values[2]))
    d=bin_32bit(dec_return_hex(initial_hash_values[3]))
    e=bin_32bit(dec_return_hex(initial_hash_values[4]))
    f=bin_32bit(dec_return_hex(initial_hash_values[5]))
    g=bin_32bit(dec_return_hex(initial_hash_values[6]))
    h=bin_32bit(dec_return_hex(initial_hash_values[7]))
    for i in range(0,64):
        if i <= 15: 
            t_1=mod_32_addition([int(h,2),int(e_1(e),2),int(Ch(e,f,g),2),int(sha_256_constants[i],16),int(w_t[i],2)])
            t_2=mod_32_addition([int(e_0(a),2),int(Maj(a,b,c),2)])
            h=g
            g=f
            f=e
            e=mod_32_addition([int(d,2),t_1])
            d=c
            c=b
            b=a 
            a=mod_32_addition([t_1,t_2])
            a=bin_32bit(a)
            e=bin_32bit(e)
        if i > 15:
            w_t.append(message_schedule(i,w_t))
            t_1=mod_32_addition([int(h,2),int(e_1(e),2),int(Ch(e,f,g),2),int(sha_256_constants[i],16),int(w_t[i],2)])
            t_2=mod_32_addition([int(e_0(a),2),int(Maj(a,b,c),2)])
            h=g
            g=f
            f=e
            e=mod_32_addition([int(d,2),t_1])
            d=c
            c=b
            b=a 
            a=mod_32_addition([t_1,t_2])
            a=bin_32bit(a)
            e=bin_32bit(e)
    hash_0 = mod_32_addition([dec_return_hex(initial_hash_values[0]),int(a,2)])
    hash_1 = mod_32_addition([dec_return_hex(initial_hash_values[1]),int(b,2)])
    hash_2 = mod_32_addition([dec_return_hex(initial_hash_values[2]),int(c,2)])
    hash_3 = mod_32_addition([dec_return_hex(initial_hash_values[3]),int(d,2)])
    hash_4 = mod_32_addition([dec_return_hex(initial_hash_values[4]),int(e,2)])
    hash_5 = mod_32_addition([dec_return_hex(initial_hash_values[5]),int(f,2)])
    hash_6 = mod_32_addition([dec_return_hex(initial_hash_values[6]),int(g,2)])
    hash_7 = mod_32_addition([dec_return_hex(initial_hash_values[7]),int(h,2)])
    final_hash = (hex_return(hash_0),
                  hex_return(hash_1),
                  hex_return(hash_2),
                  hex_return(hash_3),
                  hex_return(hash_4),
                  hex_return(hash_5),
                  hex_return(hash_6),
                  hex_return(hash_7))
    return(final_hash)