Sind openssl-Implementierungen von Hash-Funktionen bit- oder byte-orientiert?

Question

Alles ist im Titel. Ich kann keine Informationen über dieses spezifische Detail finden, und während ich ging, um die Implementierung zu überprüfen (die ich hier veröffentlichen werde, können Sie es in der Kopfzeile md32_common.h finden), konnte ich nicht wirklich sagen ...

Hier wird die HASH_UPDATE Funktion ist, die von jeder Hashfunktion Aktualisierungsfunktion aufgerufen wird (dh MD5_Update (...))

int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len) 
{ 
    const unsigned char *data = data_; 
    unsigned char *p; 
    HASH_LONG l; 
    size_t n; 

    if (len == 0) 
     return 1; 

    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL; 
    /* 
    * 95-05-24 eay Fixed a bug with the overflow handling, thanks to Wei  
    Dai 
    * <weidai@eskimo.com> for pointing it out. 
    */ 
    if (l < c->Nl)    /* overflow */ 
     c->Nh++; 
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on 
            * 16-bit */ 
    c->Nl = l; 

    n = c->num; 
    if (n != 0) { 
     p = (unsigned char *)c->data; 

     if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) { 
      memcpy(p + n, data, HASH_CBLOCK - n); 
      HASH_BLOCK_DATA_ORDER(c, p, 1); 
      n = HASH_CBLOCK - n; 
      data += n; 
      len -= n; 
      c->num = 0; 
      /* 
      * We use memset rather than OPENSSL_cleanse() here 
       deliberately. 
      * Using OPENSSL_cleanse() here could be a performance issue. 
       It 
      * will get properly cleansed on finalisation so this isn't a 
      * security problem. 
      */ 
      memset(p, 0, HASH_CBLOCK); /* keep it zeroed */ 
     } else { 
      memcpy(p + n, data, len); 
      c->num += (unsigned int)len; 
      return 1; 
     } 
    } 

    n = len/HASH_CBLOCK; 
    if (n > 0) { 
     HASH_BLOCK_DATA_ORDER(c, data, n); 
     n *= HASH_CBLOCK; 
     data += n; 
     len -= n; 
    } 

    if (len != 0) { 
     p = (unsigned char *)c->data; 
     c->num = (unsigned int)len; 
     memcpy(p, data, len); 
    } 
    return 1; 
} 

Answer 1

Obwohl Hash-Funktionen wie MD5 typischerweise auf Bitströme betreiben, Software-Implementierungen arbeiten in der Regel auf Bytes vermeiden Sie die Geschwindigkeitsbegrenzungen der Bitverschiebung (und weil Daten normalerweise in Einheiten von Bytes oder größer in jedem Fall verarbeitet werden). In dem Code geschrieben Sie die Zeile

l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL; 

multipliziert die len Parameter von 8 (von 3 mal links verschoben) die Byte-Zählung in eine Bit-Zählung zu konvertieren, so dass ich denke, es ist sicher zu sagen, dass dieser Code verwendet Bits intern, aber erwartet, dass ein Strom von Bytes übergeben wird.