Representación HEX de matriz de bytes

Question

Me siento bastante estúpido al preguntar esto, pero como no sé la respuesta, sigo adelante de todos modos.

Estoy probando algún código de autenticación y quiero saber por qué la matriz de bytes que obtengo de Rfc2898DeriveBytes debe convertirse a HEX y volver a una matriz de bytes para que inicialice correctamente mi objeto HMACSHA1. Siento que estoy haciendo algo tonto, o simplemente falta algo obvio

Mi código de cliente es una función de JavaScript basado en crypto-js;.

var key256bit = Crypto.PBKDF2(passwordEntered, saltBytes, 32, { iterations: 1000 }); 
var hmacBytes = Crypto.HMAC(Crypto.SHA1, url, key256bit, { asBytes: true }); 
var base64Hash = Crypto.util.bytesToBase64(hmacBytes); 

Mi código del lado del servidor es la siguiente;

Rfc2898DeriveBytes rfc2898 = new Rfc2898DeriveBytes(password, 
               encoding.GetBytes(salt), 1000); 
    byte[] key = rfc2898.GetBytes(32); 

    // Don't think I should need to do this. 
    // However, it wont work if I initialise HMACSHA1 
    // with the rfc2898.GetBytes(32) 
    string test = ByteArrayToString(key); 

    HMACSHA1 hmacSha1 = new HMACSHA1(encoding.GetBytes(test)); 

    byte[] computedHash = hmacSha1.ComputeHash(encoding.GetBytes(requestUri)); 
    string computedHashString = Convert.ToBase64String(computedHash); 

Mi método ByteArrayToString que atrapé de la web es;

private static string ByteArrayToString(byte[] ba) 
{ 
    StringBuilder hex = new StringBuilder(ba.Length * 2); 
    foreach (byte b in ba) 
     hex.AppendFormat("{0:x2}", b); 
    return hex.ToString(); 
} 

Así que puedo ver que tengo 32 bytes de mi llamada a rfc2898.GetBytes(32). Lo convertí en HEX usando el método ByteArrayToString para confirmar que coincide con lo que estoy viendo en mi variable de Javascript key256bit. Ahora mi variable de prueba es una cadena de longitud 64 y cuando paso eso al constuctor de HMACSHA1 usando codificación. GetBytes (prueba) es una matriz de bytes de longitud 64.

El doco en crypto-js es un poco deficiente, pero Pensé que la llamada a Crypto.PBKDF2 con un param de 32 y estaba creando una clave de 32 bytes de longitud (o 256 bits).

Cualquier aclaración es muy apreciada.

Answer 1

Sospecho que esto es la raíz del problema, en PBKDF2.js:

return options && options.asBytes ? derivedKeyBytes : 
     options && options.asString ? Binary.bytesToString(derivedKeyBytes) : 
     util.bytesToHex(derivedKeyBytes); 

Debido a que usted no ha proporcionado opciones, ya sea para asBytes o asString, es convertir la clave para una representación hexadecimal - al igual que su C# el código lo hace. Entonces, por el momento, es usando una clave de 512 bits, precisamente porque está generando 2 bytes de "clave usada" de cada byte de "clave original".

Sospecho que si especifica la opción asBytes en Javascript, simplemente funcionará sin la parte hexagonal adicional en el código C#.

Por otra parte, nunca he visto PBKDF2 antes, así que podría ser fuera de lugar ...