cryptography - decrypt - Vectores de prueba PBKDF2-HMAC-SHA2

pbkdf2 sha256 decrypt online

Question

Hay vectores de prueba para PBKDF2-HMAC-SHA1 en RFC6070 . Hay vectores de prueba para HMAC-SHA2 en RFC4231 .

Pero hasta ahora no he encontrado vectores de prueba para PBKDF2-HMAC-SHA2 en ninguna parte.

Estoy más interesado en SHA256, así que publicaré algunos vectores que calculé con mi implementación. Me alegraría que alguien pudiera verificarlos / confirmarlos o contribuir con los suyos.

Answer 1

¡Probablemente debería finalmente publicar lo que hice hace un tiempo basado en esta pregunta!

En mi repositorio Github , he compilado vectores de prueba para

• PBKDF2-HMAC-SHA-512
• PBKDF2-HMAC-SHA-384
• PBKDF2-HMAC-SHA-256
• PBKDF2-HMAC-SHA-224
• PBKDF2-HMAC-SHA-1 Y para los locos o aquellos con sistemas antiguos sin siquiera el soporte SHA-1:
• PBKDF2-HMAC-MD5

Las pruebas comenzaron con RFC6070 y las de la respuesta de @ChristianAichinger para PBKDF2-HMAC-SHA-256, y se agregaron algunas docenas más para implementar pruebas más estrictas, como las condiciones de contorno en ciertos tamaños de contraseña y sal (15/16 / 17 bytes, 63/64/65 bytes, 127/128/129 bytes, 1025 bytes, etc.), recuentos de iteraciones grandes, recuentos de gran tamaño de salida, y así sucesivamente.

Luego reuní muchas instancias de PBKDF2 y validé estos vectores de prueba en comparación con todas las implementaciones principales que pude encontrar (todo incluido también en el repositorio anterior, que a veces incluye ejecutables de Windows MinGW y generalmente incluye instrucciones de compilación de Linux), incluyendo

• Python (hashlib)
• Python (código personalizado de warner)
• C (OpenSSL)
• C (PolarSSL)
• C ++ (Cryptopp)
• .NET 4.5 (DeriveBytes de Jither)
• SQL Server (código personalizado, PBKDF2-HMAC-SHA-1 y PBKDF2-HMAC-SHA-512 solo en este momento)

Dado que estoy viendo resultados idénticos en 7 implementaciones utilizando 5 idiomas diferentes que utilizan varias bibliotecas criptográficas principales, estoy extremadamente seguro de que no solo se proporcionan los vectores de prueba precisos, sino que las implementaciones proporcionadas se pueden usar como un conjunto para validar cualquier otro conjunto de vectores de prueba deseado. Si todos están de acuerdo, entonces es correcto.

Answer 2

Vectores de prueba para PBKDF2-HMAC-SHA256:

Los valores de entrada se tomaron de RFC6070; c es el número de rondas.

Input:
 P = "password" (8 octets)
 S = "salt" (4 octets)
 c = 1
 dkLen = 20
Output:
 DK = 12 0f b6 cf fc f8 b3 2c 43 e7 22 52 56 c4 f8 37 a8 65 48 c9


Input:
 P = "password" (8 octets)
 S = "salt" (4 octets)
 c = 2
 dkLen = 20
Output:
 DK = ae 4d 0c 95 af 6b 46 d3 2d 0a df f9 28 f0 6d d0 2a 30 3f 8e


Input:
 P = "password" (8 octets)
 S = "salt" (4 octets)
 c = 4096
 dkLen = 20
Output:
 DK = c5 e4 78 d5 92 88 c8 41 aa 53 0d b6 84 5c 4c 8d 96 28 93 a0


Input:
 P = "password" (8 octets)
 S = "salt" (4 octets)
 c = 16777216
 dkLen = 20
Output:
 DK = cf 81 c6 6f e8 cf c0 4d 1f 31 ec b6 5d ab 40 89 f7 f1 79 e8


Input:
 P = "passwordPASSWORDpassword" (24 octets)
 S = "saltSALTsaltSALTsaltSALTsaltSALTsalt" (36 octets)
 c = 4096
 dkLen = 25
Output:
 DK = 34 8c 89 db cb d3 2b 2f 32 d8 14 b8 11 6e 84 cf
      2b 17 34 7e bc 18 00 18 1c


Input:
 P = "pass/0word" (9 octets)
 S = "sa/0lt" (5 octets)
 c = 4096
 dkLen = 16
Output:
 DK = 89 b6 9d 05 16 f8 29 89 3c 69 62 26 65 0a 86 87

Answer 3

Implementé PBKDF2 usando los módulos hashlib y hmac estándar en Python y verifiqué la salida contra los vectores RFC 6070 y los vectores que publicaste , coincide.

Aquí están los vectores que obtengo con un dkLen más dkLen para que coincida con el tamaño de salida más grande del resumen. Esta es la salida de pbkdf2-test-vectors.py sha256 , que tarda unos 10 minutos en ejecutarse.

PBKDF2 HMAC-SHA256 Test Vectors

Input:
  P = "password" (8 octets)
  S = "salt" (4 octets)
  c = 1
  dkLen = 32

Output:
  DK = 12 0f b6 cf fc f8 b3 2c
       43 e7 22 52 56 c4 f8 37
       a8 65 48 c9 2c cc 35 48
       08 05 98 7c b7 0b e1 7b (32 octets)


Input:
  P = "password" (8 octets)
  S = "salt" (4 octets)
  c = 2
  dkLen = 32

Output:
  DK = ae 4d 0c 95 af 6b 46 d3
       2d 0a df f9 28 f0 6d d0
       2a 30 3f 8e f3 c2 51 df
       d6 e2 d8 5a 95 47 4c 43 (32 octets)


Input:
  P = "password" (8 octets)
  S = "salt" (4 octets)
  c = 4096
  dkLen = 32

Output:
  DK = c5 e4 78 d5 92 88 c8 41
       aa 53 0d b6 84 5c 4c 8d
       96 28 93 a0 01 ce 4e 11
       a4 96 38 73 aa 98 13 4a (32 octets)


Input:
  P = "password" (8 octets)
  S = "salt" (4 octets)
  c = 16777216
  dkLen = 32

Output:
  DK = cf 81 c6 6f e8 cf c0 4d
       1f 31 ec b6 5d ab 40 89
       f7 f1 79 e8 9b 3b 0b cb
       17 ad 10 e3 ac 6e ba 46 (32 octets)


Input:
  P = "passwordPASSWORDpassword" (24 octets)
  S = "saltSALTsaltSALTsaltSALTsaltSALTsalt" (36 octets)
  c = 4096
  dkLen = 40

Output:
  DK = 34 8c 89 db cb d3 2b 2f
       32 d8 14 b8 11 6e 84 cf
       2b 17 34 7e bc 18 00 18
       1c 4e 2a 1f b8 dd 53 e1
       c6 35 51 8c 7d ac 47 e9 (40 octets)


Input:
  P = "pass/0word" (9 octets)
  S = "sa/0lt" (5 octets)
  c = 4096
  dkLen = 16

Output:
  DK = 89 b6 9d 05 16 f8 29 89
       3c 69 62 26 65 0a 86 87 (16 octets)