¿La longitud de ronda desconocida hace que el hash no se pueda rastrear?

1

Así que estoy en un compromiso y tomé algunos hachís, pero romperlos no ha servido de nada. Creo que conozco el tipo de hash (PBKDF2-HMAC-SHA256) pero no estoy seguro de qué tamaño redondo utilizaron. Esto me hizo pensar, ¿esto no hace que sea imposible de descifrar o me estoy perdiendo algo? Porque incluso si supiera que conocía la contraseña y la sal de texto sin formato (obviamente, un escenario muy artificial), aún tendría que probar cada tamaño de redondeo hasta encontrar el que usaron.

¿Es correcto pensar esto o me estoy perdiendo algo?

EDITAR: Esta es una información importante mirando hacia atrás y me disculpo por las confusiones sobre la falta de las rondas. La aplicación devuelve hashes en dos partes diferentes de un objeto JSON. {..., "Contraseña": "(Base64encoded (27 caracteres))", "PasswordSalt": "(Base64encoded (24 caracteres))" , ...}. Es por eso que los hashes no incluyen un identificador de rondas.

Por lo tanto, PBKDF2-HMAC-SHA256 proviene de cómo almacenan las contraseñas en una parte diferente de la aplicación y fue todo lo que pude encontrar a través de OSINT. Mirando las longitudes de la contraseña y jugando con Python passlib parece que las contraseñas se almacenan como pbkdf2_sha1. Puedo asegurarme de que estoy en lo cierto, pero repasando todas las rondas y comprobando si hay alguna contraseña que tenga. Todavía llevará un tiempo, ya que, como ha dicho la comunidad, 100,000 rondas no son desconocidas y, lamentablemente, no están usando el valor predeterminado de 29,000.

EDITAR EDITAR: Simplemente ejecuté mi contraseña conocida contra su hash a través de todas las rondas 1-100,000 y no obtuve ningún impacto. Parece que mi intuición de que Sha1 estaba equivocada. Probando SHA-256 ahora con el mismo enfoque.

EDITAR EDITAR: Bueno, mi esperanza se está agotando rápidamente. He intentado SHA_1,256 y 512 de 1 a 100,000 rondas y ninguna de ellas coincide con mi hash. Las longitudes y valores de hash parecen coincidir perfectamente con la descripción, pero los experimentos parecen ser diferentes.

Sé que esto no es realmente un foro de programación, pero aquí está el código que estaba usando para verificar mi hash contra todos los generados.

import concurrent.futures
global quit
from passlib.hash import pbkdf2_sha512
quit = False

def hasher(round, quit):
    if(not quit):
        hash = pbkdf2_sha512.using(salt=(passlib.utils.binary.ab64_decode('xpN14Zl95QQNOKffgsERSw==')), rounds=round).hash('Password').split('$')[-1]
    if(hash[0:5] == '278Vu'):
        print(round) #found it
        quit = True
    if(round % 5000 == 0):
        print(round) #status update


exec = concurrent.futures.ThreadPoolExecutor(max_workers=4)
print("Execing")
for i in range(1,100001):
    exec.submit(hasher,i, quit)

EDITAR EDITAR EDITAR: Parece que la herramienta de identificador hash aquí enlace los ha etiquetado como contraseñas de Peoplesoft. No estoy seguro de si esto es un falso positivo porque la aplicación no parece utilizar peoplesoft en ningún lugar. También parece que los hashes de Peoplesoft no son salados y el mío devuelve una sal. Hay una publicación sobre el tema aquí, enlace pero es vaga. ¿Alguna ayuda en este sentido?

    
pregunta staticFlow 09.06.2018 - 09:05
fuente

1 respuesta

1

Por lo general, esto solo sería una barrera temporal leve para el agrietamiento.

Dejar el número de rondas sería una capa delgada de oscuridad. La única forma en que tal hash podría incluso funcionar sería si el software tuviera una forma codificada o algorítmica para determinar el número de rondas. De modo que el software podría simplemente ser invertido para descubrir el número de rondas.

También sería bastante inusual. La mayoría de los formatos de hash que usan rondas incluyen el número de rondas como parte del hash en sí (el "1000" en este ejemplo, tomado de la lista de hashes hashcat de ejemplo ):

sha256:1000:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt

Esto significa que la solución más sencilla es simplemente generar una versión del hash con muchos números de rondas:

sha256:1:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt
sha256:2:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt
sha256:3:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt
sha256:4:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt
sha256:5:MTc3MTA0MTQwMjQxNzY=:PYjCU215Mi57AYPKva9j7mvF4Rc5bCnt

... y luego alimente todos de ellos a su software de craqueo. (Debido a que el número de rondas en este formato hash está diseñado para ser variable, el software de craqueo debería poder manejarlo bien).

Dicho esto, generalmente hay un límite superior práctico para el número de rondas, más allá del cual los usuarios interactivos tardarían demasiado en tolerar la espera de que se verifique su contraseña. 100,000 rondas serían bastante inusuales, pero no imposible . Pero si se trata de una aplicación personalizada y personalizada, un número inusualmente alto de rondas podría ser tolerable. Por lo tanto, si se trata de una aplicación a medida, intentar "ocultar" el número de rondas podría hacer que sea un poco más difícil para el atacante. Y dado que PBKDF2 es un hash bastante lento, si asumimos que el defensor escogió un número bastante alto de rondas, este enfoque podría hacer las cosas más difíciles.

Entonces, si un ataque en rondas de 1 a 50,000, usando listas de palabras y ataques comunes, no produjera ningún resultado en uno o dos días ... Me gustaría pensar que podría ser un tipo de hash diferente - y probablemente también intentaría agarrar el software / firmware que genera / verifica los hashes y lo revisa. De hecho, probablemente lo haría de todos modos porque estaba esperando que terminara el trabajo de craqueo. :)

    
respondido por el Royce Williams 09.06.2018 - 16:31
fuente

Lea otras preguntas en las etiquetas