Probleme mit RtlRunEncodeUnicodeString

[slemke76]

Hallo,

1000 Dank - tiefste Dankbarkeit - wenn du nicht aus Berlin kommen würdest (zu weit weg) würde ich mit ner Kiste Bier vorbeikommen .

Ich werde dann mal als nächstes das Decode selber probieren zu implementieren Ich habe erstmal einen kräftigen Schubser in die richtige Richtung bekommen.

lg
Sebastian

[TiGü]

Zitat von slemke76:

1000 Dank - tiefste Dankbarkeit - wenn du nicht aus Berlin kommen würdest (zu weit weg) würde ich mit ner Kiste Bier vorbeikommen .

Gibt es bei euch keine Post?

[slemke76]

Hallo,

darüber lässt sich reden

Ich habe das ganze jetzt durchgearbeitet und (hoffentlich) auch verstanden (ein paar Fragen sind noch unten .
Mein nächster Schritt wäre jetzt, die RtlRunDecodeUniCodeString einzuführen; die Parametertypen sind gleich, ein "RtlRunDecodeUniCodeString(@Hash, @UnicodeString);" sollte im o.g. Source also gehen (?).

Was ich getan habe: Ein Breakpoint _vor_ dem RtlRunEncodeUniCodeStringsetzen, Inhalt von UnicodeString in den überwachten Ausdrücken einsetzen, diesen Aufklappen und in UnicodeString.Buffer liegt der Wert "TestString", wie erwartet.

Dann Einzelschritt für Encode & Decode machen - leider steht dann _nicht_ wieder der "TestString" im UnicodeString.Buffer (bei gleichem Hash)?

Ich habe auch noch paar "untergeordnete" Fragen (ich möchte nicht Dumm sterben :

1. mit GetMem wird Speicher an der Adresse "P" in Größe der Struktur UNICODE_STRING bereit gestellt, mit CopyAndSkipString der Inhalt von Source an die Speicheradresse P kopiert. Richtig? Wird dann mit Str := P; die Adresse der Variable "Source" ebenfalls auf P gesetzt? Ich vermute, damit man auf das Ergebnis später einfach über die Variable source zugreifen kann? Was passiert mit der alten Speicheradresse von source? Leck?

2. Wenn ich "ShowMessage(WideCharLenToString(UnicodeString.Buf fer, UnicodeString.Length div 2));" oder auch einfach "ShowMessage(source);" zum Anzeigen des Inhaltes der Variable benutze, funktioniert das im ersten Durchlauf, im zweiten bekomme ich eine Exception - warum?

Kann jemand auflösen, warum zum Henker die Decode Funktion nicht laufen will? Ich habe schon alles mögliche probiert (u.a. auch die Variable neu zu initialisieren), aber nichts klappt.

Einen aktuellen Source habe ich nochmal angehängt.
Es gibt keinen Fehler, aber ich bekomme auch meinen Wert nicht zurück...!?

lg
Sebastian

[Zacherl]

Die Parameter sind nicht gleich. Bei der Decode Funktion ist der Hash ein UCHAR und kein PUCHAR

Bei dem ganzen CopyAndSkipString Kram hast du btw. auf jeden Fall einen Buffer Overflow eingebaut. Der Speicher, den du dir per GetMem holst ist unter 32 Bit immer 8 Byte groß. In der Funktion schreibst du aber im Falle von "TestString" 22 Bytes.

[Zacherl]

Habe den Code jetzt nochmal etwas genauer debuggt, weil mir dieser CopyAndSkipString einfach absolut unsinnig vorkam und habe wohl recht gehabt. Das Problem liegt an einer komplett anderen Stelle.

RtlInitUnicode String erstellt keinen neuen Buffer für den String, sondern setzt das entsprechende Feld lediglich auf die Adresse des Source Strings. PAnsiChar/PWideChar Stringkonstanten packt Delphi allerdings scheinbar in eine read-only Section der Anwendung, weshalb jedlicher Schreibversuch zu einer Access Violation führt.

Delphi-Quellcode:

var
  Source: PWideChar;
begin
  Source := 'TestString';
  // Oops, this is read-only memory
  Source[1] := 'x';

RtlRunEncodeUnicodeString für seinen Teil erwartet aber logischerweise einen Buffer, der beschrieben werden kann.

Folgender Code funktioniert, basiert nicht auf irgendwelchen Pseudo-Funktionen und erzeugt auch keine Memory-Leaks:

Delphi-Quellcode:

type
  UNICODE_STRING = packed record
    Length: Word;
    MaximumLength: Word;
    Buffer: PWideChar;
  end;
  PUNICODE_STRING = ^UNICODE_STRING;

procedure RtlInitUnicodeString(DestinationString: PUNICODE_STRING; SourceString: LPWSTR); stdcall;
  external 'ntdll.dll';
procedure RtlRunEncodeUnicodeString(Hash: PUCHAR; Str: PUNICODE_STRING); stdcall;
  external 'ntdll.dll';
procedure RtlRunDecodeUnicodeString(Hash: UCHAR; Str: PUNICODE_STRING); stdcall;
  external 'ntdll.dll';

var
  Source: PWideChar;
  UnicodeString: UNICODE_STRING;
  Hash: UCHAR;
  S: array of WideChar;
begin
  Source := 'TestString';

  // Init
  SetLength(S, Length(Source) + 1);
  ZeroMemory(@S[0], Length(S) * SizeOf(S[0]));
  CopyMemory(@S[0], Source, Length(S) * SizeOf(S[0]));
  RtlInitUnicodeString(@UnicodeString, @S[0]);

  // Encode
  // RtlRunEncodeUnicodeString automatically calculates a hash, if the initial value is zero
  // http://doxygen.reactos.org/dc/d4b/lib_2rtl_2encode_8c_a2b44614e96788912d167d7cac4b7b501.html#a2b44614e96788912d167d7cac4b7b501
  Hash := 0;
  RtlRunEncodeUnicodeString(@Hash, @UnicodeString);

  // Decode
  RtlRunDecodeUniCodeString(Hash, @UnicodeString);
end;

Auch gehen würde folgendes (normale Stringkonstanten landen nicht in der read-only Section bzw. werden bei Zuweisung vermutlich umkopiert):

Delphi-Quellcode:

var
  Source: WideString;
  UnicodeString: UNICODE_STRING;
  Hash: UCHAR;
begin
  Source := 'TestString'#0;
  RtlInitUnicodeString(@UnicodeString, @Source[1]);
  Hash := 0;
  RtlRunEncodeUnicodeString(@Hash, @UnicodeString);

Dann aber nicht vergessen vorher per Hand eine #0 an den Source String anzuhängen.

[uligerhardt]

Zitat von Zacherl:

Auch gehen würde folgendes (normale Stringkonstanten landen nicht in der read-only Section bzw. werden bei Zuweisung vermutlich umkopiert):

Delphi-Quellcode:

var
  Source: WideString;
  UnicodeString: UNICODE_STRING;
  Hash: UCHAR;
begin
  Source := 'TestString'#0;
  RtlInitUnicodeString(@UnicodeString, @Source[1]);
  Hash := 0;
  RtlRunEncodeUnicodeString(@Hash, @UnicodeString);

Dann aber nicht vergessen vorher per Hand eine #0 an den Source String anzuhängen.

Die #0 fügt Delphi (AFAIK ) schon automatisch an verwaltete Strings an. Und statt @Source[1] lieber den passenden Cast nehmen:

Delphi-Quellcode:

var
  Source: WideString;
  UnicodeString: UNICODE_STRING;
  Hash: UCHAR;
begin
  Source := 'TestString';
  RtlInitUnicodeString(@UnicodeString, PWideChar(Source));
  Hash := 0;
  RtlRunEncodeUnicodeString(@Hash, @UnicodeString);
  RtlRunDecodeUniCodeString(Hash, @UnicodeString);
end.

[Zacherl]

Zitat von uligerhardt:

Die #0 fügt Delphi (AFAIK ) schon automatisch an verwaltete Strings an.

Wäre mir neu Würde ich mich, selbst wenn es so ist, aber auf keinen Fall drauf verlassen. "Normale" Strings sind in Delphi nicht nullterminiert, sondern enthalten ein vorangestelltes Längenbyte. Unter dem Gesichtspunkt ist für den Delphi Compiler ja keine Notwendigkeit gegeben noch irgendwelche Nullen hinzuzufügen.

Edit:
Zumindest bei neueren Delphi Versionen stehen auf den ersten Blick tatsächlich zwei Nullbytes hinter dem String.

Zitat von uligerhardt:

Und statt @Source[1] lieber den passenden Cast nehmen

Macht keinen Unterschied:

Code:

Unit1.pas.63: RtlInitUnicodeString(@UnicodeString, @Source[1]);
005C7383 8B45F8           mov eax,[ebp-$08]
005C7386 E8252DE4FF       call @WStrToPWChar
005C738B 50               push eax
005C738C 8D45F0           lea eax,[ebp-$10]
005C738F 50               push eax
005C7390 E8B7FFFFFF       call RtlInitUnicodeString
Unit1.pas.64: RtlInitUnicodeString(@UnicodeString, PWideChar(Source));
005C7395 8B45F8           mov eax,[ebp-$08]
005C7398 E8132DE4FF       call @WStrToPWChar
005C739D 50               push eax
005C739E 8D45F0           lea eax,[ebp-$10]
005C73A1 50               push eax
005C73A2 E8A5FFFFFF       call RtlInitUnicodeString