XOR-Resultat als String

[TomDooley]

Ich habe zwei Schlüssel (Key1 und Key2) mit xor verknüpft:

Delphi-Quellcode:

  for i := 1 to x do
    Result[x] := Chr(Byte(Key1[x]) xor Byte(Key2[x]));

Der Resultatstring enthält die richtigen Werte aber eben Bit für Bit:

Beispiel:

Delphi-Quellcode:

Result = #3#3#2#2#3#A#A#A

ich möchte aber:

Delphi-Quellcode:

Result = '33223AAA'

[Klaus01]

du könntest die '#' mit StringReplace entfernen.

Grüße
Klaus

[nahpets]

Hallo,

kurz und knapp

Delphi-Quellcode:

Result := AnsiReplaceText(Result,'#','');  // in StrUtils definiert, ggfls. in Uses aufnehmen.

Stephan

[DGL-luke]

Hmm... du willst eine lesbare ausgabe der bytewerte?

Da gibts drei Möglichkeiten:

a) Ausgabe als Hex->zwei stellen pro byte ("FF01AB")
b) Ausgabe in Dezimal -> drei stellen pro byte ("255255001010011")
c) ausgabe im klartext mit delimiter->mind. zwei stellen pro byte (#255#255#1#10#11")

Das ganze ist über verschiedene funktionen machbar.

@die zwei anderen komiker: loooool.....

[Klaus01]

@DGL Luke:

wenn man aus:

#3#3#2#2#3#A#A#A


diese machen will:

33223AAA

Dann sind die genannten Methoden sind nicht so verkehrt.

Wenn die Ausgabe eine ganz andere sein soll, dann greifen sie natürlich nicht.

Grüße
einer der Komiker

[TomDooley]

Hallo alle

Danke erstmal für die prompten Antworten. Falls die Problemstellung nicht überall gleich rüberkam: sorry.

Stephan und Klaus haben mich schon richtig verstanden. Es geht mir darum die Hex-Werte lesbar (in diesem Fall ohne $) darzustellen. Dies entspricht dann Lösung a.) von Luke.
Ich kann aber $ wohl nicht mit Replace ersetzen, da dieses Zeichen kein Teil vom String darstellt sondern nur die Hex-Repräsentation der nächsten Stelle anzeigt.

[shmia]

@Klaus01 und nahpets:
Ihr habt das System noch nicht verstanden, wie man mit Pascal nicht druckbare Zeichen darstellt.
Wenn ich an einen String z.B. ein CarriageReturn + Linefeed anhängen möchte schreibe ich:

Delphi-Quellcode:

s :='Zeile, abgeschlossen mit CR/LF'#13#10;

Das Rautezeichen ist nur ein Escapezeichen, dass aber im eigentlichen String nicht vorkommt.
Deshalb sind alle Ersetzungsaktion sinnlos.

Delphi-Quellcode:

s := #65#66#67;  // ist das Gleiche wie 'ABC'

[OldGrumpy]

Zitat:

Zitat von TomDooley

Ich habe zwei Schlüssel (Key1 und Key2) mit xor verknüpft:

Delphi-Quellcode:

  for i := 1 to x do
    Result[x] := Chr(Byte(Key1[x]) xor Byte(Key2[x]));

Der Resultatstring enthält die richtigen Werte aber eben Bit für Bit:

Beispiel:

Delphi-Quellcode:

Result = #3#3#2#2#3#A#A#A

ich möchte aber:

Delphi-Quellcode:

Result = '33223AAA'

Delphi-Quellcode:

function XorMyKeys(const Key1, Key2: Array of Byte): string;
var
  i :Integer;
begin
  for i:=Low(Key1) to High(Key1) do
  begin
    result:=result+Format('%.2x',[Key1[i] xor Key2[i]]);
  end;
end;

Ungetestet, Fehlerbehandlung fehlt natürlich auch noch. Ausserdem wird angenommen dass Key1 und Key2 gleich lang sind und den gleichen Indexbereich haben. Hat sicherlich noch Optimierungspotential.
Raus kommt ein String der die Hexäquivalente der XOR-Verschluesselung enthält.

[Hawkeye219]

Hallo,

mit der Funktion BinToHex aus der Unit Classes kann man recht einfach einen Pufferinhalt in einen lesbaren Hexstring überführen:

Delphi-Quellcode:

var
  sInput : string;
  sOutput : string;
begin
  sInput := #3#3#2#2#3#$A#$A#$A;
  SetLength (sOutput, 2 * Length(sInput));
  BinToHex (PChar(sInput), PChar(sOutput), Length(sInput));
end;

Gruß Hawkeye

[TomDooley]

Das kommt meinem Wunsch nun doch sehr nahe. Ich bekomme:

Delphi-Quellcode:

03030202030A0A0A

Muss ich da manuell nun jedes zweite Zeichen entfernen oder gibt es da auch noch eine elegantere Lösung? Bzw. ich denke ich müsste vor dem xor nicht ein Byte mit einem Zeichen sondern ein Byte mit zwei Zeichen befüllen (bzw. ein Nibble mit einem Zeichen). Geht das?

[OldGrumpy]

Das kommt ganz auf Deinen Wertebereich an. Jede Hexziffer kann einen von 16 Zuständen anzeigen. Wenn Du nicht mehr als 16 unterschiedliche Zeichen in Deinen Keys hast (oder Werte, oder was auch immer), dann kannst Du das zusammenfassen. Einfach jedes zweite Zeichen "wegmachen" hat mehrere gravierende Nachteile, zum einen musst Du dann annehmen dass der Wertebereich auf jeden Fall maximal von 0 bis 15 geht. Wenn das XOR den Wert 16 ergibt (Hex: $10), würdest du die 1 "wegmachen" und es bleibt nur eine Null übrig.

Auch wenn ich jetzt schon weiss, was Du antworten wirst: Ohne mehr Infos kanns keine richtige Antwort geben.

[Klaus01]

Das würde auch gehen:

Delphi-Quellcode:

result:='';
for i := 1 to x do
  result := result+IntToHex( ( (ord(Key1[x]) xor ord(Key2[x]) ),2);

Grüße
Klaus

[TomDooley]

Hier nochmal ein Beispiel:

Delphi-Quellcode:

0000 //String1
1111 //String2
xor
1111 //erwartetes Resultat

Da ich jetzt aber einzelne Zeichen in jeweils ein Byte konvertiere (Byte(String1[x]), sehen die String binär dargestellt wie folgt aus:

Delphi-Quellcode:

00000001 00000001 00000001 00000001 //String1 binär
00000000 00000000 00000000 00000000 //String2 binär
xor
00000001 00000001 00000001 00000001 //Resultat binär
01010101                            //Resultat als String

richtig wäre aber:

Delphi-Quellcode:

00010001 00010001 //String1 binär
00000000 00000000 //String2 binär
xor
00010001 00010001 //Resultat binär
1111              //Resultat als String --> korrekt

[xaromz]

Hallo,

Du kannst bei IntToHex angeben, wie viele Stellen mindestens verwendet werden. Wenn Du zwei angibst, wird eben mit 0 aufgefüllt.

Gruß
xaromz

[OldGrumpy]

Zitat:

Zitat von TomDooley

Hier nochmal ein Beispiel:

Delphi-Quellcode:

0000 //String1
1111 //String2
xor
1111 //erwartetes Resultat

Aehm, *so* gilt das nur für binäre Werte, wenn Du da einen String "1111" hast, dann steht im Speicher hexadezimal 31 31 31 31. Oder meinst Du einen String "#1#1#1#1"?

Zitat:

Zitat von TomDooley

Da ich jetzt aber einzelne Zeichen in jeweils ein Byte konvertiere (Byte(String1[x]), sehen die String binär dargestellt wie folgt aus:

Delphi-Quellcode:

00000001 00000001 00000001 00000001 //String1 binär
00000000 00000000 00000000 00000000 //String2 binär
xor
00000001 00000001 00000001 00000001 //Resultat binär
01010101                            //Resultat als String

Nein, dann steht im Speicher immer noch b00110001 b00110001 b00110001 b00110001 :)

Zitat:

Zitat von TomDooley

richtig wäre aber:

Delphi-Quellcode:

00010001 00010001 //String1 binär
00000000 00000000 //String2 binär
xor
00010001 00010001 //Resultat binär
1111              //Resultat als String --> korrekt

Du willst also einzelne Nibbles benutzen. Achtung: In ein Nibble passen nur Werte von Null bis 15. Bist Du sicher, dass Du mit diesem Wertebereich auskommst?
Was Du vermutlich willst, ist HexToInt. Für jedes resultierende Byte gibst Du ihm zwei Zeichen aus dem String zu fressen.
Damit kannst Du dann Deinen String in Schüben von acht Zeichen in DWORDs wandeln und jeweils passend XORen.

[TomDooley]

Zitat:

Aehm, *so* gilt das nur für binäre Werte

Das ist mir klar, jedoch suche ich eben eine Funktion welche mir die Arbeit (Umwandlung für xor, xor, Umwandlung in String) abnimmt.

Zitat:

Du willst also einzelne Nibbles benutzen. Achtung: In ein Nibble passen nur Werte von Null bis 15. Bist Du sicher, dass Du mit diesem Wertebereich auskommst?

Ja, das bin ich. Für die Eingabe stehen nur die "Hex-Ziffern" 0-F zur Verfügung.

Ich hab's bei mir jetzt mal so gelöst:

Delphi-Quellcode:

  for i := 1 to x do
    Result := Result + IntToHex((StrToInt('$'+ Key1[x]) xor StrToInt('$'+ Key1[x])),1);