es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Mi código para el algoritmo SHA256 en Python no acepta longitudes superiores a 56 caracteres (448 bits).

Por lo que entiendo, el problema ocurre cuando agrego ceros al mensaje hasta que sea múltiplo de 512. Si el relleno resulta en una longitud de mensaje rellenado de 512, funciona, pero si el mensaje en bits es >= 448, la longitud del mensaje rellenado es de 1024 y no funciona.

No sé cómo utilizar cada fragmento de datos para la lista de palabras o para la parte de compresión.

  • ¿Alguien sabe cómo se procesa cada bloque (64 bytes)?
  • ¿Tengo que crear una lista de palabras diferente para cada 512 bits?

Intenté usar vectores de prueba, pero no fueron de mucha ayuda.

Estoy hashando ba7816bf8f01cfea414140de5dae2223bda12ae1a5324sfdserew3ra utilizando el algoritmo sha256.

Valor hash correcto: 1caa150674ab1aed030dc69f9b86dbcbc412e6e1dd20344eeaa21687acae7789

Mi resultado: efcf3579753ef16f9f515f61d901eaafa03aafa6b9e092fe3d087efdfd25c41e

Mi definición para el relleno de la lista de palabras:

self.convertToBytes = "".join(format(ord(char), "08b") for char in msg)
padding = (512 - len(self.add1) - 64) % 512
self.zFill = self.add1 + "".zfill(padding)
Agregar el valor ASCII de la longitud de la msg a zFill.
La longitud de self.addlen es siempre un múltiplo de 512.

self.addlen = self.zFill + format(len(self.convertToBytes), "08b").zfill(64)[0:64]

addtoW = [
    self.addlen[i : i + 32]  # cada 32 bits se separa en una lista; cada entrada de 32 bits.
    for i in range(0, len(self.addlen), 32)
]
La longitud de self.W es siempre de 64, sin importar la longitud del mensaje.

si len(addtoW) < 64:
self.W = addtoW + [
    "".zfill((64 - len(addtoW)) * 32)[i : i + 32] for i in range(0, 64 - len(addtoW))
]
Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Como un experto en tecnología de la información especializado en Python, algoritmos, seguridad, hash y sha256, comprendo el problema con la almohadilla del mensaje cuando no es múltiplo de 512. Cuando la almohadilla resulta en una longitud de mensaje almohadillado de 512, el algoritmo de hashing funciona. Sin embargo, si el mensaje está en bits mayores o iguales a 448, y la longitud del mensaje acolchado es de 1024, el algoritmo de hashing no funciona.

    Para aclarar algunas preguntas que tengo, necesito saber cómo se procesa cada bloque de datos, que es de 64 bytes. Además, me gustaría preguntar si tengo que crear una lista de palabras diferente para cada 512 bits.

    He intentado usar vectores de prueba, pero no fueron útiles para abordar mis inquietudes.

    Como ejemplo, intenté resumir el mensaje ba7816bf8f01cfea414140de5dae2223bda12ae1a5324sfdserew3ra utilizando el algoritmo sha256, y esperaba un valor hash de 1caa150674ab1aed030dc69f9b86dbcbc412e6e1dd20344eeaa21687acae7789. Sin embargo, mi resultado fue efcf3579753ef16f9f515f61d901eaafa03aafa6b9e092fe3d087efdfd25c41e.

    Para abordar el problema del acolchado, he definido una función que convierte el mensaje en bytes y lo acolcha con ceros hasta que sea un múltiplo de 512. La función luego agrega la longitud del mensaje en bits al mensaje acolchado y separa cada bloque de 32 bits en una lista. La longitud de la lista siempre es de 64, incluso si la longitud del mensaje es más corta que 448 bits.

    self.convertToBytes = "".join(format(ord(char), "08b") for char in msg)
    
    padding = (512 - len(self.add1) - 64) % 512
    
    self.zFill = self.add1 + "".zfill(padding)
    
    # se agrega el valor ascii de la longitud del mensaje a zFill
    # la longitud de self.addlen es siempre un múltiplo de 512
    self.addlen = self.zFill + format(len(self.convertToBytes), "08b").zfill(64)[0:64]
    addtoW = [
        self.addlen[i : i + 32]  # se separa cada bloque de 32 bits en una lista; cada entrada = 32 bits.
        for i in range(0, len(self.addlen), 32)
    ]
    
    # la longitud de self.W siempre es de 64 sin importar la longitud del mensaje
    # si len(addtoW) < 64:
    self.W = addtoW + [
        "".zfill((64 - len(addtoW)) * 32)[i : i + 32] for i in range(0, 64 - len(addtoW))
    ]
    

    En general, la solución al problema del acolchado requiere convertir el mensaje en bytes y rellenarlo con ceros hasta que sea un múltiplo de 512. Luego se agrega la longitud del mensaje en bits al mensaje acolchado y se separan los bloques de 32 bits en una lista. La longitud de la lista siempre es de 64, incluso si la longitud del mensaje es más corta que 448 bits.

Comments are closed.