unicodefähiges Base32Decode

[semo]

Ich bin auf der Suche nach einer Funktion um Base32 strings zu decodieren.
Es existieren zwar einige Funktionen, nur scheinbar kommt da durch die Umstellung auf Unicode (Delphi 2009) nur Murks bei rum.

Hat jemand eventuell einen Tip für mich?

[himitsu]

Hast du mal soeine nichtfunktionierende Implementation, welche die ansonsten gefällt, zur Hand?

Und Base32 ist nicht gleich Base32 ... gibt da ja unterschiedliche Zeichensätze

z.B.:
A..Z 2..7 =
oder
0..9 A..H K..N P R..Z =


PS: schau mal ins DEC ... vielleicht ist dort ja was dafür drin

[semo]

Das mit den beiden Versionen hab ich gesehen,
ich benötige die Standardvariante mit A..Z 2..7.

DEC - *sich am Hinterkopf kratzt* - da war doch was. Ich schau mal nach, danke für den Tip schon einmal.

[himitsu]

Hatte auf die Schnelle keinen "kleinen" Decoder gefunden,
aber wenn du eine kleine Version hast, dann könnte man notfalls mal schauen, was nicht geht.

Auch wenn es nicht so aufwändig ist, wäre es dennoch einfacher was Fertiges zu reparieren.

[semo]

http://www.experts-exchange.com/Prog..._20913763.html

[GPRSNerd]

Dir ist schon bewusst, dass das hier wahrscheinlich kaum einer lesen kann ohne Zugang zu experts-exchange.com?

[semo]

Öhm, muss man da nicht einfach nur immer seitenweise nach unten scrollen?
Dann kann man die Lösung einsehen.
Ich poste aber hier noch mal den dort gelisteten Code aus dem Jahre 2004:

Delphi-Quellcode:

function Base32Encode(source: String): String;
const
  alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var
  i: Integer;
  nr: Int64;
begin
  result := '';
  while length(source) >= 5 do  begin
    nr := 0;
    for i := 1 to 5 do
      nr := nr * 256 + ord(source[i]);
    for i := 1 to 8 do begin
      result := result + alphabet[(nr mod 32) + 1];
      nr := nr div 32;
    end;
    delete(source, 1, 5);
  end;
  nr := 0;
  if length(source) > 0 then begin
    for i := 1 to length(source) do
      nr := nr * 256 + ord(source[i]);
    for i := 1 to 8 do begin
      if nr > 0 then begin
        result := result + alphabet[(nr mod 32) + 1];
        nr := nr div 32;
      end
      else
        result := result + '=';
    end;
  end;
end;

function Base32Decode(source: String): String;
const
  alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var
  i: Integer;
  nr: Int64;
  p: Integer;
begin
  result := '';
  while length(source) >= 8 do  begin
    nr := 0;
    for i := 8 downto 1 do begin
      p := pos(source[i], alphabet);
      if p > 0 then
        nr := nr * 32 + p-1
      else
        nr := nr * 32;
    end;
    for i := 1 to 5 do begin
      result := result + chr(nr mod 256);
      nr := nr div 256;
    end;
    delete(source, 1, 8);
  end;
end;

[GPRSNerd]

Ich kann in dem Code erstmal nichts Unicode-kritisches erkennen, weshalb die Funktionen unter D2009+ nicht mehr gehen sollten.Ich habe den Code gerade unter D2010 mal ausprobiert und zusätzlich eine Variante mit AnsiStrings ausprobiert (also D2007-kompatibel) und im Ergebnis keine Unterschiede entdecken können.

Seltsamerweise erzeugt der Decode einen teilweise reversierten String des Inputs aus dem Encode, das aber in beiden Versionen. Ich vermute also mal, das die Funktionen an sich einen Bug haben...

[GPRSNerd]

Hier Code von Embarcadero, der einwandfrei auch unter D2010 funktioniert:

Delphi-Quellcode:

const
  ValidChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';

function FromBase32String(const inString : string) : string;
var
   outString : string;
   aByte : byte;
   bit_buffer,
   inIndex,
   bits_in_buffer,
   outSize,
   pos1, pos2,
   i : integer;
begin
   outSize := (length(inString) * 5 div 8) + 1;
   outString := StringOfChar(' ',outSize);
   pos1 := Pos(inString[1],ValidChars) - 1;
   pos2 := Pos(inString[2],ValidChars) - 1;
   bit_buffer := pos1 or (pos2 shl 5);
   if length(inString) < 3 then begin
      aByte := bit_buffer;
      outString[1] := Chr(aByte);
      result := outString;
      exit;
   end;
   bits_in_buffer := 10;
   inIndex := 3;
   for i := 1 to outSize + 1 do begin
      aByte := bit_buffer;
      outString[i] := Chr(aByte);
      bit_buffer := bit_buffer shr 8;
      bits_in_buffer := bits_in_buffer - 8;
      while (bits_in_buffer < 8) and (inIndex <= length(inString)) do begin
         pos1 := (Pos(inString[inIndex],ValidChars) - 1);
         Inc(inIndex);
         bit_buffer := bit_buffer or (pos1 shl bits_in_buffer);
         bits_in_buffer := bits_in_buffer + 5;
      end;
   end;

   result := outString;
end;

function ToBase32String(const inString : string) : string;
var
   currentChar,
   outString : string;
   inIndex,
   validIndex,
   high : integer;
   aByte,
   currentByte : byte;
begin
   high := 5;
   inIndex := 1;
   while inIndex <= Length(inString) do begin
      currentChar := inString[inIndex];
      currentByte := Ord(currentChar[1]);
      if (high > 8) then begin
         // get the last piece from the current byte, shift it to the right
         // and increment the byte counter
         validIndex := (currentByte shr (high - 5)) mod 256;
         Inc(inIndex);
         currentChar := inString[inIndex];
         currentByte := Ord(currentChar[1]);
         if (inIndex <> Length(inString) + 1) then begin
            // if we are not at the end, get the first piece from
            // the next byte, clear it and shift it to the left
            aByte := (currentByte shl (16 - high)) mod 256;
            validIndex := ((aByte shr 3 ) or validIndex) mod 256;
         end;
         high := high - 3;
      end else if(high = 8) then begin
         Inc(inIndex);
         validIndex := currentByte shr 3;
         high := high - 3;
      end else begin
         // simply get the stuff from the current byte
         aByte := currentByte shl (8 - high) mod 256;
         validIndex := aByte shr 3;
         high := high + 5;
      end;
      currentChar := ValidChars[validIndex + 1];
      outString := outString + currentChar;
   end;
   result := outString;
end;

Ein Vergleich mit den beiden Funktionen von dir lässt auf einen Fehler im Encoder schließen, da der Decoder das gleiche Ergebnis erzeugt.

[himitsu]

Delphi-Quellcode:

function Base32Decode(source: String): String;
...
begin
  result := '';
  while length(source) >= 8 do  begin

Ein Bug ist erstmal hier, somit kann der Decoder nut mit String umgehen, welche auch Uncodiert nur vielefache von 5 Zeichen ergeben. (also encodiert 8 Zeichen)

[GPRSNerd]

Deshalb füllt der Encoder ja auch mit Padding-Bytes hinten auf (=).

[himitsu]

Zitat:

Zitat von GPRSNerd

Deshalb füllt der Encoder ja auch mit Padding-Bytes hinten auf (=).

Nein, die = geben an, wieviele "zusättzlich" reinkodierte Zeichen nicht mit zum Ursprungsstring gehören.

Diese sind nicht dafür da, um die 8er-Gruppen zu bilden.

[GPRSNerd]

Fehler in Encoder gefunden! Das ShiftLinks mit der Multiplikation war verkehrt herum:

Aus

Delphi-Quellcode:

nr := nr * 256 + ord(source[i]);

muss

Delphi-Quellcode:

nr := nr * 256 + ord(source[5+1-i]);

gemacht werden.
Dito mit der 2. Berechnung darunter.

Delphi-Quellcode:

function Base32Encode(source: String): String;
const
  alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var
  i: Integer;
  nr: Int64;
begin
  result := '';
  while length(source) >= 5 do
  begin
    nr := 0;
    for i := 1 to 5 do
      nr := nr * 256 + ord(source[5+1-i]);
    for i := 1 to 8 do
    begin
      result := result + alphabet[(nr mod 32) + 1];
      nr := nr div 32;
    end;
    delete(source, 1, 5);
  end;
  nr := 0;
  if length(source) > 0 then
  begin
    for i := 1 to length(source) do
      nr := nr * 256 + ord(source[Length(source)+1-i]);
    for i := 1 to 8 do
    begin
      if nr > 0 then
      begin
        result := result + alphabet[(nr mod 32) + 1];
        nr := nr div 32;
      end
      else
        result := result + '=';
    end;
  end;
end;

So stimmts dann auch mit dem anderen Code überein und geht unter D2009+.

[himitsu]

Zitat:

Zitat von GPRSNerd

So stimmts dann auch mit dem anderen Code überein und geht unter D2009+.

Solange man dieses Verfahren nicht auf Binärdaten anwendet.

S := 'abcde'#0#0#0#0#0'xyz';

Außerdem würde ich in diesem Fall den uncodierten Text als AnsiString geklarieren, denn mit Unicode läuft es hier nicht richtig.

[semo]

Ok, das encrypt und anschließendes decrypt produzieren nun ein stimmiges Ergebnis.

Ich habe nun folgende Verständnisschwierigkeit:
Ich habe in einer von einem Tauschbörsenprogramm produzierten Datei (ein Auszug daraus befindet sich im Anhang) einen Hexstring ('J3XEJMMFO3UE3Z5RMMKCWU35F7TCGGCF') enthalten.
Wie komme ich nun von diesen Hexstring, der ein Base32 encodierter SHA1 Hash ist, auf den urspünglichen SHA1 Hashwert ('4EEE44B18576E84DE7B163142B537D2FE6231845')?
Diesen Wert habe ich mittels einem Onlineconverter ermittelt (http://darkfader.net/toolbox/convert/).
Auch der ermittelte SHA1 Hashwert der Datei per Hashtab spuckt mir den SHA1 Hashwert '4EEE44B18576E84DE7B163142B537D2FE6231845' aus.

[himitsu]

Zitat:

Ich habe nun folgende Verständnisschwierigkeit:

Base32 > Binär > Hex

also Base32Decode und danach vermutlich BinToHex ... es könnte eventuell noch passieren, daß zwischendurch die Bytereihenfolge gedreht werden muß

PS: Man könnte auch beides in ein einheitliches Binärformat bringen?
( Base32Decode und HexToBin )

[semo]

Zitat:

Base32 > Binär > Hex

Genauso hab ich es gemacht.
Danke nochmal!