MD5 Länge einfügen als 64 Bit?

[himitsu]

ich hab's mal etwas zerlegt

Delphi-Quellcode:

Result :=
    Format('%.2x%.2x%.2x%.2x', [(h0 {shr 0}) mod 256,
      (h0 shr 8) mod 256, (h0 shr 16) mod 256, (h0 shr 24) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [(h1 {shr 0}) mod 256,
      (h1 shr 8) mod 256, (h1 shr 16) mod 256, (h1 shr 24) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [(h2 {shr 0}) mod 256,
      (h2 shr 8) mod 256, (h2 shr 16) mod 256, (h2 shr 24) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [(h3 {shr 0}) mod 256,
      (h3 shr 8) mod 256, (h3 shr 16) mod 256, (h3 shr 24) mod 256]);

Delphi-Quellcode:

Result :=
    Format('%.2x%.2x%.2x%.2x', [h0 mod 256,
      (h0 div 256) mod 256, (h0 div 65536) mod 256, (h0 div 16777216) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [h1 mod 256,
      (h1 div 256) mod 256, (h1 div 65536) mod 256, (h1 div 16777216) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [h2 mod 256,
      (h2 div 256) mod 256, (h2 div 65536) mod 256, (h2 div 16777216) mod 256])
  + Format('%.2x%.2x%.2x%.2x', [h3 mod 256,
      (h3 div 256) mod 256, (h3 div 65536) mod 256, (h3 div 16777216) mod 256]);

im Grunde besteht doch LongWord aus 4 Byte

also "shr 0" ist wirklich sinnlos ... aber ab es dringelassen, damit alles "gleich" berechnet wird.

and $ff sorgt dafür, daß nur das niederwertigste Byte im Ergebnis steht.
also wäre das "and $ff" im Susammenhanb mit "shr 24" sinnlos, da dort das höherwertigste Byte an die niederwertigste Stelle verschoben wurde und es somit nix höheres mehr gibt.

Bei IntToHex wird der Wert $00112233 auch so ausgegeben, aber eigentlich müßte es 33221100 sein, da das niederwertigste Byte zuerst kommen muß.

Mit BinToHex würde es richtig dargestellt.


wenn du in meine, von mir mal verlinkten, "optimierteren" Version reinschaust, dann könnte man entdecken, daß ich da sozusagen h0 bis h4 zusammen in einem Array hintereinander hab ... somit kann ich diese alle zusammen/auf_einmal über BinToHex ('ne eigene Version) umwandeln

[fortuneNext]

Ah okay, dann hab ich das mit dem SHR und $ff auch verstanden.
Mit diesen 100en von Typkonvertierungen und Endians komm ich aber immernoch durcheinander. Von Dez auf Bin, von da wieder auf dez, um dann wieder auf hex zu kommen, und das dann als string ausgeben, der statt LE dann BE sein muss...

Mein nächster Versuch hätte wohl so ausgesehen:

Delphi-Quellcode:

function LEtoBE(i: string): string;
ASM
  BSWAP EAX
end;


  Result := LEtoBE(IntToHex((h0) mod 256, 2)) + LEtoBE(IntToHex((h0 div 256) mod 256, 2)) + LEtoBE(IntToHex((h0 div 65536) mod 256, 2)) + LEtoBE(IntToHex((h0 div 16777216) mod 256, 2)) +
            LEtoBE(IntToHex((h1) mod 256, 2)) + LEtoBE(IntToHex((h1 div 256) mod 256, 2)) + LEtoBE(IntToHex((h1 div 65536) mod 256, 2)) + LEtoBE(IntToHex((h1 div 16777216) mod 256, 2)) +
            LEtoBE(IntToHex((h2) mod 256, 2)) + LEtoBE(IntToHex((h2 div 256) mod 256, 2)) + LEtoBE(IntToHex((h2 div 65536) mod 256, 2)) + LEtoBE(IntToHex((h2 div 16777216) mod 256, 2)) +
            LEtoBE(IntToHex((h3) mod 256, 2)) + LEtoBE(IntToHex((h3 div 256) mod 256, 2)) + LEtoBE(IntToHex((h3 div 65536) mod 256, 2)) + LEtoBE(IntToHex((h3 div 16777216) mod 256, 2));

Allerdings kommt dort dann überhaupt nichts mehr raus. Also hab ich mir jetzt auch mal die Format() Funktion angesehen - und festgestellt, dass das tatsächlich wesentlich mehr Sinn macht, da eine Hex-Funktion ja bereits eingebaut ist. Meine Lösung wäre deiner dann fast gleich:

Delphi-Quellcode:

  Result := LowerCase(Format('%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x',
      [(h0 shr 0) mod 256, (h0 shr 8) mod 256, (h0 shr 16) mod 256, (h0 shr 24) mod 256,
       (h1 shr 0) mod 256, (h1 shr 8) mod 256, (h1 shr 16) mod 256, (h1 shr 24) mod 256,
       (h2 shr 0) mod 256, (h2 shr 8) mod 256, (h2 shr 16) mod 256, (h2 shr 24) mod 256,
       (h3 shr 0) mod 256, (h3 shr 8) mod 256, (h3 shr 16) mod 256, (h3 shr 24) mod 256]));

Mit dieser Formulierung denke ich, fällt es mir an leichtesten, es zu verstehen...


Jedenfalls danke ich für die super Hilfe, das ganze hat mich ein großes Stück weiter gebracht


mfg
fortuneNext

[himitsu]

Machen wir es einfach mal kurz ... wie ich schon sagt ... in meinem anderem Code (siehe irgendwo verlinkter Thread), hab ich alles auf einmal umcodiert

Mach mal aus h0, h1, h2, h3: longword; ein a: array[0..3] of longword; und verwende dann über alles ein BinToHex.
Im Code dann statt h0 einfach h[0] verwenden.

Delphi-Quellcode:

SetLength(Result, SizeOf(h) * 2);
BinToHex(@h, PChar(Result), SizeOf(h));

ich glaub das müßte vollkommen ausreichen

[fortuneNext]

Jup, so funktionierts jetzt auch

Ich kam bloß mit BinToHex nicht grade gut klar...

[himitsu]

och, so schwer ist das eigentlich nicht ... man muß nur den Speicherbereich vorher resservieren, da dieses nicht von BinToHex übernommen wird. (in Delphi läßt es sich ja sonst sehr leicht mit strings umgehen ... man muß sich um fast nix kümmern )

einzeln geht es übrigens auch ... läßt sich am Einfachsten über eine Temp-Variable (hier S) lösen

Delphi-Quellcode:

SetLength(S, SizeOf(LongWord) * 2);
BinToHex(@h0, PChar(S), SizeOf(LongWord));
Result := S;
BinToHex(@h1, PChar(S), SizeOf(LongWord));
Result := Result + S;
BinToHex(@h2, PChar(S), SizeOf(LongWord));
Result := Result + S;
BinToHex(@h3, PChar(S), SizeOf(LongWord));
Result := Result + S;

nja, oder man geht hängt es im String zusammen ^^ (muß man nur etwas mehr nachrechnen)
[delphi]SetLength(Result, SizeOf(LongWord) * 2 * 4);
BinToHex(@h0, @Result[1], SizeOf(LongWord));
BinToHex(@h1, @Result[9], SizeOf(LongWord));
BinToHex(@h2, @Result[17], SizeOf(LongWord));
BinToHex(@h3, @Result[25], SizeOf(LongWord));