Hex to Base64

[Cubysoft]

Hey Leute,

ich durchsuche seit gestern Nacht das Internet nach etwas Brauchbaren, wurde aber leider nicht fündig. Ich habe derzeit folgendes Problem: Ich möchte einen Hex-Wert (02 01 AA B6 00 00) mit Base64 codieren. Das Ergebnis sollte in diesem Falle "AgGqtgAA" sein. Ich gebe auch offen zu, dass ich nicht genau weiß, was Base64 überhaupt ist. Die Wikipedia Seite dazu habe ich mir schon durchgelesen, bin aber leider nicht in der Lage selbst eine Funktion dafür zu schreiben. Ich habe u.A. herausgefunden, dass das mit irgendeiner Indy Komponente gehen soll, gefunden habe ich diese aber nicht.

Ich wäre euch wirklich sehr dankbar, wenn ihr mir bei meinem Problem helfen könnt. Wichtig ist, dass der Hex-Wert derzeit im Stringformat vorliegt, das könnte man allerdings ändern

[mjustin]

Indy enthält Klassen für Base64

Delphi-Quellcode:

uses
  ..., IdCoder, IdCoderMIME;

var
  Bytes: TIdBytes;
  Base64String: String;
begin
  //...
  Bytes := ...; // array of bytes
  //...
  Base64String := TIdEncoderMIME.EncodeBytes(Bytes);
  //...
  Bytes := TIdDecoderMIME.DecodeBytes(Base64String);
  //...
end;

(siehe http://stackoverflow.com/questions/3...ng-delphi-2007)

Man kodiert allerdings nie "Hex Werte" sondern 8 Bit Binärdaten nach Base64. Das Bytes-Array muss daher mit den Bytes zu 02 01 AA B6 00 00 gefüllt werden.

[p80286]

vielleicht hilft Dir der Anhang weiter

Gruß
K-H

[gammatester]

Wenn Du nicht eine der Base64/Mime-Funktionen zur Verfügung hast, kann man auch mit Bordmitteln arbeiten. Das Program unten liefert die Ausgabe AgGqtgAA

Delphi-Quellcode:

program b64;

{$apptype console}

const
  CT64: array[0..63] of ansichar = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

{---------------------------------------------------------------------------}
function Base64Str(psrc: pointer; L: integer): ansistring;
  {-Base64 string of memory block of length L pointed by psrc}
var
  q,r: integer;
  b0,b1,b2: byte;
type
  pByte = ^byte;
begin
  result := '';
  if (L>0) and (psrc<>nil) then begin
    q := L div 3;
    r := L mod 3;
    while q>0 do begin
      b0 := pByte(psrc)^; inc(pByte(psrc));
      b1 := pByte(psrc)^; inc(pByte(psrc));
      b2 := pByte(psrc)^; inc(pByte(psrc));
      result := result + CT64[(b0 shr 2) and $3f]
                       + CT64[((b0 shl 4) and $30) or ((b1 shr 4) and $0f)]
                       + CT64[((b1 shl 2) and $3c) or ((b2 shr 6) and $03)]
                       + CT64[b2 and $3f];
      dec(q);
    end;
    if r=2 then begin
      b0 := pByte(psrc)^; inc(pByte(psrc));
      b1 := pByte(psrc)^;
      result := result + CT64[(b0 shr 2) and $3f]
                       + CT64[((b0 shl 4) and $30) or ((b1 shr 4) and $0f)]
                       + CT64[(b1 shl 2) and $3c]
                       + '=';
    end
    else if r=1 then begin
      b0 := pByte(psrc)^;
      result := result + CT64[(b0 shr 2) and $3f]
                       + CT64[(b0 shl 4) and $30]
                       + '==';
    end;
  end;
end;


var
  s: ansistring;
const
  xx: array[0..5] of byte = ($02, $01, $AA, $B6, $00, $00) ;
begin
  s := Base64Str(@xx, sizeof(xx));
  writeln(s);
end.

[Popov]

Diese Unit habe ich mal unter Delphi 3 genutzt. Ist sehr einfach zu handhaben (ein Beispiel ist in der Unit bei).

[Sir Rufo]

Zusammenfassend kann man also sagen, das so eine HEX-Zeichenfolge eine Folge von Bytes darstellt, was im Übrigen auch so eine Base64-Zeichenfolge macht.

BTW Diese HEX-Zeichenfolge kann man auch als Base16-Zeichenfolge bezeichnen.

Somit ist auch der Weg klar: HEX-Zeichenfolge => Byte-Folge => Base64-Zeichenfolge

[himitsu]

EncdDecd
BinToHex / HexToBin

Aber das Indyzeugs hab ich auch schon paar mal genutzt.

Zitat:

gefunden habe ich diese aber nicht

Strg+Shift+F > Delphi-Installverzeichnis + "base64"

[Cubysoft]

Also ersteinmal vielen vielen Dank für eure Antwort. Ich stecke in der "binären" Materie leider einfach noch nicht wirklich drin und bin von den ganzen Dingen derzeit überwältigt. Ich kann euch mal erklären, wie sich der HEX-Wert zusammensetzt, vielleicht gibt es dann eine bessere Lösung:

02 01 AA B6 00 00

1.Byte: 02 (immer)
2.Byte: eine Zahl von 1-250 (im Hex-Format)
3-xByte: eine Zahl von 1-X im Format little endian (das macht mir gerade auch zu schaffen) auch HEX
x+1Byte: ein 0-Byte

Ich habe gerade schon damit scheusslich Probleme, weil ich das mit dem little endian nicht gebacken bekomme. Derzeit ist meine Lösung einfach nur hässlich. Ich konvertiere die Zahl (1-X) in einen Hex-String und schiebe dann jeweils in Zweierpäckchen die Bytes in die andere Reihenfolge. Auf diesem Weg schaffe ich es zwar, den HEX-Code als String darzustellen, aber am Rest scheitere ich kläglich. Am Besten wäre es natürlich, wenn ich einfach direkt alles in ein Byte Array gepackt bekomme, aber dafür reicht mein Wissen leider nicht aus. Es wäre genial, wenn ihr hierbei nochmal helfen könntet


Vielen vielen Dank schonmal für die Zahlreichen Antworten!

[p80286]

Zitat von Cubysoft:

Am Besten wäre es natürlich, wenn ich einfach direkt alles in ein Byte Array gepackt bekomme, aber dafür reicht mein Wissen leider nicht aus. Es wäre genial, wenn ihr hierbei nochmal helfen könntet

dann Schau Dir mal #2 an!
Das könnte hilfreich sein.

Gruß
K-H

P.S.
Hex ist übriges das gleiche wie Base16

[Cubysoft]

Achsoooooo jetzt weiß ich endlich was base 64 ist DD danke Ich schau mir deinen Post nochmal genauer an

EDIT: Ja hier ist auch schon das Problem:

Der Wert für das 2. Byte liegt als String vor (dezimal, 1-250). Der Wert für die Bytes danach liegt ebenfalls als String vor (aber nicht little endian sondern eben normal). Ich weiß weder, wie ich den Wert für Byte 2 als Byte konvertiere, noch wie ich einen Integer beliebiger länge (Byte 3-x) in ein little endian byte array konvertiere. Vor allem deswegen, weil die größe eines Integers - soweit ich weiß - unter 32 und 64bit unterschiedlich ist..