2016-09-01 5 views
0

Für Krypto-Experten habe ich eine Frage, die mir kürzlich in den Sinn kam. Nehmen wir zum Beispiel an, dass wir eine lange Folge von Bytes haben, und wir wollen diese Zeichenfolge in eine Hash-Funktion einfügen, die wir zur Veranschaulichung als SHA1 verwenden können. Wie wir wissen, nimmt SHA1 Eingaben in 64-Byte-Blöcken vor und jede Hash-Funktion, die afaik benötigt, um die Nachricht vor der Verarbeitung aufzufüllen. Jetzt ist die Frage, ob es der letzte Brocken ist, der gepolstert werden muss oder die ganze Schnur? Es wird eine Rolle spielen, denn am Ende des Auffüllens werden wir die Länge anhängen. Danke allen.Padding Ausgabe von Long Hashes

Antwort

0

Jetzt ist die Frage, dass es der letzte Brocken ist, der gepolstert werden muss oder die ganze Schnur?

Ich glaube beide Dinge sind gleich. Das Auffüllen der gesamten Zeichenfolge bedeutet, dass nur der letzte Block aufgefüllt wird.

Einige Pseudo-Code aus guten alten Wiki here

Ein Blick auf den Code könnte Ihnen einige Einblicke geben:

von Genommen: mattmahoney.net/dc/sha1.c

void SHA1PadMessage(SHA1Context *context) 
{ 
    /* 
    * Check to see if the current message block is too small to hold 
    * the initial padding bits and length. If so, we will pad the 
    * block, process it, and then continue padding into a second 
    * block. 
    */ 
    if (context->Message_Block_Index > 55) 
    { 
     context->Message_Block[context->Message_Block_Index++] = 0x80; 
     while(context->Message_Block_Index < 64) 
     { 
      context->Message_Block[context->Message_Block_Index++] = 0; 
     } 

     SHA1ProcessMessageBlock(context); 

     while(context->Message_Block_Index < 56) 
     { 
      context->Message_Block[context->Message_Block_Index++] = 0; 
     } 
    } 
    else 
    { 
     context->Message_Block[context->Message_Block_Index++] = 0x80; 
     while(context->Message_Block_Index < 56) 
     { 

      context->Message_Block[context->Message_Block_Index++] = 0; 
     } 
    } 

    /* 
    * Store the message length as the last 8 octets 
    */ 
    context->Message_Block[56] = context->Length_High >> 24; 
    context->Message_Block[57] = context->Length_High >> 16; 
    context->Message_Block[58] = context->Length_High >> 8; 
    context->Message_Block[59] = context->Length_High; 
    context->Message_Block[60] = context->Length_Low >> 24; 
    context->Message_Block[61] = context->Length_Low >> 16; 
    context->Message_Block[62] = context->Length_Low >> 8; 
    context->Message_Block[63] = context->Length_Low; 

    SHA1ProcessMessageBlock(context); 
} 
+0

Aber in Ihrem Fall Länge der gesamten Zeichenkette nicht gleich der Länge des letzten nicht aufgefüllten Abschnitts der Zeichenfolge. Und nach dem Auffüllen müssen wir die Länge in den letzten 8 Bytes einfügen. Aber welche Länge ist das? Ist es die Länge der ganzen Nachricht? –

+1

ja ... Länge der gesamten Nachricht mit der Polsterung – PRP

+0

Wenn ja danke, sehr feine Details verwischt manchmal Dinge :) –