Rappresentazione HEX dell'array di byte

Question

Mi sento piuttosto stupido a chiedere questo, ma poiché non conosco la risposta, vado avanti comunque.

Sto provando un codice di autenticazione e voglio sapere perché l'array di byte che ottengo da Rfc2898DeriveBytes deve essere convertito in HEX e tornare a un array di byte per poter inizializzare correttamente il mio oggetto HMACSHA1. sto facendo qualcosa di stupido, o semplicemente manca qualcosa di ovvio

il mio codice cliente è una funzione javascript in base a 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); 

mio codice lato server è la seguente;

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); 

Il mio metodo ByteArrayToString che ho cancellato dal web è;

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(); 
} 

Così posso vedere che ricevo 32 byte dalla mia chiamata a rfc2898.GetBytes(32). L'ho convertito in HEX utilizzando il metodo ByteArrayToString per confermare che corrisponde a quello che sto vedendo nella mia variabile chiave Javascript256bit. Ora la mia variabile di test è una stringa di lunghezza 64 e quando la passiamo al constuctor di HMACSHA1 usando encoding.GetBytes (test) è una matrice di byte di lunghezza 64.

Il doco su crypto-js è un po 'carente, ma Ho pensato che la chiamata a Crypto.PBKDF2 con un parametro di 32 e stava creando una chiave di 32 byte (o 256 bit).

Qualsiasi chiarimento è molto apprezzato.

Answer 1

Ho il sospetto che questa è la radice del problema, in PBKDF2.js:

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

Poiché non hai fornito le opzioni sia per asBytes o asString, è convertendo la chiave per una rappresentazione esadecimale - proprio come il vostro C# il codice fa. Quindi nel momento in cui lo è utilizzando una chiave a 512 bit, proprio perché stai generando 2 byte di "chiave usata" da ciascun byte di "chiave originale".

Sospetto che se si specifica l'opzione asBytes in Javascript, funzionerà senza la parte esadecimale aggiuntiva nel codice C#.

Poi di nuovo, non ho mai visto PBKDF2 prima, così ho potuto essere lontano di base ...