Hex to Base64

[himitsu]

Sind da wirklich Leerzeichen zwischen den Hex-Werten?

• Leerzeichen entfernen (Replace im String)
• Hex nach Bin konvertieren (String -> ByteArray oder Stream)
• Bin nach Base64 konvertieren (ByteArray oder Stream -> String)

[Sir Rufo]

Zitat:

Zitat von Cubysoft (Beitrag 1300649)

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..

Ob es wohl möglich wäre, dass du anstatt einer abstrakten Beschreibung einmal konkrete Werte zeigen könntest, so z.B.

Delphi-Quellcode:

function Foo( Arg1 : Byte; Arg2 : string; Arg3 : Int64 ) : string;
begin
  // da weiss ich nicht wie
end;

procedure Test;
begin
  Assert(
    // Eingangswerte 
    Foo(42, '42', 42) 
    // erwartetes Ergebnis
    = 'Magic' );
end;

Darunter können wir uns dann konkret etwas vorstellen

[Cubysoft]

Ich weiß nicht genau was du meinst, aber ich versuche gerade aus Werten einer Datenbank einen Base64 kodierten String zu erstellen, mit dem ein anderes Programm arbeiten kann. Dazu habe ich den genannten Aufbau:

1.Byte: Header (immer 02)
2.Byte: Anzahl (liegt als String vor: Beispiele: 1;15;123;250;... -> der Wert schwankt zwischen 1 und 250)
3-xByte: ID (liegt als String vor: Beispiele: 1;2345;65234;... -> der Wert ist immer positiv und ungleich 0 ansonsten theoretisch beliebige größe, derzeit aber nich größer als 3Bytes)
x+1Byte: 0Byte

Mein Ansatz zum Erstellen des Byte Arrays:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  BArray: TByteDynArray;
  s2: string;
  t: Byte;
begin
  SetLength(BArray, ?); //Ich weiß vorher noch nicht wie groß es wird, weil die ID ja beliebig groß ist
  BArray[0] := $02;
  t := StrToInt(ed_anzahl.Text);
  BArray[1] := t;
  //hier müsste ich dann die ID als little endian, also verkehrt herum hinzufügen
  BArray[?] := $00;
end;

Ich hoffe das Problem ist jetzt klar. Wenn ich das Byte Array erstmal richtig aufgebaut habe, versuche ich mal #2 :)

[p80286]

Zitat:

Zitat von Cubysoft (Beitrag 1300645)

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

a) Die Werte die Du hast, bestehen aus 6 Byte (immer!) dann ist #2 für Dich erst einmal in Ordung, wenn Du Die Werte so übernimmst wie sie zur Verfügung stehen.

b) Du hast eine Struktur

1. feld=x02
2. feld=x01..xFA
3. feld=zahl (16,24,32,64Bit integer?)
4. Feld=x00

In Deinem Beispiel wäre das ein 24Bit Integer.
D.H. Du benötigst mehrere Byte-Arrays mit unterschiedlichen Längen oder ein Byte-Array [0..10] und eine Längenangabe wieviele Bytes übersetzt werden sollen.

Und zu Little Endian:
dez:511 = x01FF [little Endian] = xFF01 [BigEndian]

Gruß
K-H

Nachtrag:
was spricht dagegen 17 als x11 oder x0011 oder x000011 oder x00000011 ... zu betrachten?

[Sir Rufo]

Ok, ich versuche jetzt mal das

Zitat:

1.Byte: Header (immer 02)
2.Byte: Anzahl (liegt als String vor: Beispiele: 1;15;123;250;... -> der Wert schwankt zwischen 1 und 250)
3-xByte: ID (liegt als String vor: Beispiele: 1;2345;65234;... -> der Wert ist immer positiv und ungleich 0 ansonsten theoretisch beliebige größe, derzeit aber nich größer als 3Bytes)
x+1Byte: 0Byte

zu übersetzen

1. Header
   Delphi-Quellcode:

   byte

   $02
2. Anzahl
   Delphi-Quellcode:

   byte

   $01 .. $FA
3. ID
   Delphi-Quellcode:

   byte

   /
   Delphi-Quellcode:

   word

   /
   Delphi-Quellcode:

   ?? (3 Bytes)

   $000000 .. $FFFFFF
4. Ende
   Delphi-Quellcode:

   byte

   $00

Woher du diese Zahlen bekommst oder wie diese Zahlen dort wo immer du diese herbekommst vorliegen ist absolut unerheblich. Es kommt nur darauf an, was diese bedeuten.

Ist das jetzt soweit korrekt?

PS:

Bitte zeige uns auch noch den Wert der ID, die dann zu deinem Eingangs-Beispiel 02 01 AA B6 00 00 führt.

[Cubysoft]

Okay, ich habe mir nochmal genau angeschaut, wie der Base64 Code vom dem besagten Programm selbst generiert wird:

1 Byte: Header
1 Byte: Anzahl
4 Byte: ID
1 Byte: 0-Byte

Das bedeutet, das ByteArray hätte immer die größe 7Byte! Header und Anzahl bekomme ich nun hin, das 0-Byte ist natürlich auch kein Problem. Das Problem ist derzeit nur noch die ID

Ich würde dafür gerne eine saubere Lösung haben. In der Theorie weiß ich, wie man aus einem BigEndian ein LittleEndian mache, nämlich indem ich einfach die Indizes der Bytes umgekehrt anordne:

BigEndian:

|---0---| |---1---| |---2---|
1001 0010 1100 1010 1111 0000

Der selbe Wert als LittleEndian wäre dann ja:

1111 0000 1100 1010 1001 0010
|---0---| |---1---| |---2---|

Ich müsste nun den String (decimal, zB 23;453;69121) in irgendeinen 4Byte Integer-Container eintragen und dann die Bytes von hinten nach vorne in das Array eintragen und das bekomme ich nicht hin.

Also das wäre nochmal sehr lieb :)

[Sir Rufo]

Zitat:

Zitat von Cubysoft (Beitrag 1300659)

1 Byte: Header
1 Byte: Anzahl
4 Byte: ID
1 Byte: 0-Byte

Bist du dir jetzt auch wirklich sicher mit den 4 Bytes?

Bislang waren es immer ausdrücklich 3 Bytes ... woher kommt jetzt diese wundersame Byte-Vermehrung?

Und welchen Wert hat ID um auf die Byte-Folge in dem ersten Beitrag zu kommen?
Obwohl, diese Byte-Folge im ersten Beitrag ist ja nun auch wieder falsch, weil nur 6 Bytes ... :roll:

[Cubysoft]

Naja es ist so. Es gibt eine Wiki, wo der Aufbau dieses Konstrukts erklärt wird. Dort wird die ID nicht auf 4 Bytes festgelegt sondern ist Variabel. Das Programm selbst erzeugt die eigenen Codes konstant mit 4 Bytes, was ich vorher nicht bemerkt habe. Das heißt im Endeffekt: Das Programm erkennt alles, auch wenn die ID 2,3,5 oder 6 Bytes groß ist. Mit 4 Bytes bin ich allerdings auf der Sicheren Seite. 3 Bytes wären allerdings auch vollkommen ausreichend. Mich würden beide Varianten interessieren.. mir fehlt wie gesagt einfach der Ansatz

im ersten Beitrag war der HEX Code 02 01 AA B6 00 00

Darauf folgt: B6 AA (bzw 00 B6 AA oder bei 4 bytes 00 00 B6 AA) ist die ID in BigEndian also "46762" in Dezimal

Ich brauche im Prinzip ja nur eine Möglichkeit, die 3 oder 4 Bytes (wie auch immer ist eigentlich egal) aus dem String, der in dem Fall "46762" ist herauszubekommen und das auch noch falsch herum..

[Sir Rufo]

Also suchst du sowas hier

Delphi-Quellcode:

program dp_185013;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Classes,
  System.SysUtils;

procedure OutputBuffer( ABuffer: TBytes );
var
  I: Integer;
begin
  for I := low( ABuffer ) to high( ABuffer ) do
  begin
    write( IntToHex( ABuffer[ I ], 2 ), ' ' );
    if ( I + 1 - low( ABuffer ) ) mod 16 = 0 then
      Writeln;
  end;
  Writeln;
end;

procedure Test;
var
  LStream: TMemoryStream;
  LBuffer: TBytes;
begin
  LStream := TMemoryStream.Create;
  try
    // Daten in den Stream
    LStream.WriteData( $02 );
    LStream.WriteData( Byte( StrToInt( '1' ) ) );
    LStream.WriteData( Int32( StrToInt( '46762' ) ) );
    LStream.WriteData( $00 );

    // Stream-Inhalt nach TBytes kopieren
    SetLength( LBuffer, LStream.Size );
    LStream.Position := 0;
    LStream.Read( LBuffer, Length( LBuffer ) );
    // Ausgabe der TBytes zur Kontrolle
    OutputBuffer( LBuffer );

  finally
    LStream.Free;
  end;
end;

begin
  try
    Test;
  except
    on E: Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

Die Ausgabe ist dann

Code:

02 01 AA B6 00 00 00

[Sir Rufo]

In diesem Zusammenhang solltest du dir auch mal diesen Beitrag durchlesen

http://www.delphipraxis.net/1291673-post112.html

und die Lösung von mir anschauen, wie dort die Daten hin- und hergeschoben werden.

http://www.delphipraxis.net/1291673-post112.html