schreibender Zugriff auf private Variablen ?

**MaBuSE**

Hallo,

ich habe ein kleines Problem. Ich müsste eine private Variable ändern (von außen) Das ist normalerweise nicht möglich und auch nicht gewollt. Kennt jemand einen dirty hack um das trotzdem zu machen?

Beisp:

zusammenfalten · markieren

Delphi-Quellcode:

			unit Unit1;

interface

uses

  SysUtils;

type

  TmyTest = class(TObject)

  private

    sTest: string;

  public

    constructor Create;

    function getTest: string;

  end;

implementation

{$R *.dfm}

{ TmyTest }

constructor TmyTest.Create;

begin

  sTest := IntToStr(Random(100));

end;

function TmyTest.getTest: string;

begin

  Result := sTest;

end;

end.

Ich möchte nun in der Unit2 schreibend auf sTest zugreifen.

Aber ich kann Unit1 nicht ändern !!!

Wäre sTest protected, wäre es kein Problem.
Innerhalb der selben Unit kann ich auf sTest zugreifen, aber das bringt mir nix.
Class Helper bringt mich auch nicht weiter, da er ja auch von "außen" zugreift.

zusammenfalten · markieren

Delphi-Quellcode:

			unit Unit2;

interface

uses

  SysUtils, Unit1;

type

type

  TmyTestHelper = class helper for TmyTest

    procedure setTest(s: string);

  end;

implementation

{$R *.dfm}

{ TmyTestHelper }

procedure TmyTestHelper.setTest(s: string);

begin

  // hier gibt es leider keinen schreibenden Zugriff auf sTest

end;

end.

Hat jemand eine Idee?
(vieleicht mit Code Beisp.

, evtl mit RTTI?)

**Flocke**

Vielleicht geht's so: Einander zugewiesene Strings zeigen ja normalerweise solange auf denselben Speicherbereich, bis man sie ändert. Irgendwo in der Struktur TmyTest muss es einen Zeiger auf denselben String geben, wie getTest ihn zurückliefert.

(ungetestet)

zusammenfalten · markieren

Delphi-Quellcode:

			type

  PString = ^string;

function FindStringReference(Obj: Pointer; Size: Integer; const TheString: string): PString;

begin

  while Size >= 8 do

  begin

    Obj := Pointer(Integer(Obj) + 4);

    dec(Size, 4);

    if PInteger(Obj)^ = Integer(@TheString) then

    begin

      Result := PString(Obj);

      Exit;

    end;

  end;

  Result := nil;

end;

// Aufrufen mit:

FindStringReference(myObj, SizeOf(myObj), myObj.getTest)^ := 'Neuer Text';

**Phoenix**

Okay, jetzt wird's dirty:

Caste eine Methode von dem Objekt, auf dem Du die Variable ändern willst, nach TMethod. TMethod hat ein Property Data und ein Property Code. Das Data Property ist ein Zeiger auf den Datenbereich des Objektes.

In dem solltest Du nach dem aktuellen Wert Suchen und so die Speicherstelle herausfinden können. Es sollte gehen, das dann nach String zu casten und zu verändern.

Allerdings gebe ich da keine Gewähr

**MaBuSE**

Zitat von Flocke:

Vielleicht geht's so: Einander zugewiesene Strings zeigen ja normalerweise solange auf denselben Speicherbereich, bis man sie ändert. Irgendwo in der Struktur TmyTest muss es einen Zeiger auf denselben String geben, wie getTest ihn zurückliefert.

(ungetestet)
...

Danke, das teste ich mogen mal aus...

**Apollonius**

@Flocke: Gute Idee, aber ich glaube, dass da noch ein paar kleine Fehler drin sind...

zusammenfalten · markieren

Delphi-Quellcode:

			function FindStringReference(Obj: Pointer; Size: Integer; const TheString: string): PString;

begin

  while Size >= 8 do

  begin

    Obj := Pointer(Integer(Obj) + 4);

    dec(Size, 4);

    if PInteger(Obj)^ = Integer(TheString) then //Der String selbst ist der Zeiger - wir brauchen nicht seine Adresse!

    begin

      Result := PString(Obj);

      Exit;

    end;

  end;

  Result := nil;

end;

FindStringReference(myObj, MyObj.InstanceSize, myObj.getTest)^ := 'Neuer Text';//SizeOf liefert für alle Klassen 4 zurück, da es Zeiger sind

**sirius**

@Phoenix: Da steht aber nur der Zeiger. Das wird recht kompliziert.

Erweiterte Möglichkeit zu Phoenix:
Variable ist "String", also dynamisch. Damit muss sie definitv in der RTTI auftauchen.

Die RTTI zum Datenrecord einer Klasse findest du so

markieren

Delphi-Quellcode:

			var inittable:^pointer;

begin

  inittable:=pointer(integer(self.classparent)+vmtinittable); //oder noch mehr classparent's; je nachdem wo man hinwill

  //oder nicht im Parent, dann pointer(integer(ppointer(self)^)+vmtinittable);

                          //bzw. pointer(integer(mytest.classInfo)+vmtinittable);

  if inittable<> nil then 

    inittable:=inittable^

  else 

    //diese Klasse hat (in der Generation) keine dynamischen Komponenten

Dort (bei inittable) dürftest du erstmal ein $0E für Record finden, dann einen Shortstring der nur aus dem Längenbyte besteht (indem 0 drinn steht), und dann kommt folgender Datenkonstrukt

zusammenfalten · markieren

Delphi-Quellcode:

			//RTTI eines Records

type PPropContent=^TPropContent;

     TPropContent=record

       RecordData:pointer; //RTTI einer dynamischen Variablen innerhalb des Records

       Position:LongInt; //Position der Variablen im Record

     end;

type PRecordData=^TRecordData;

     TRecordData=record

       ParamCount:cardinal;  //Größe des Records insgesamt

       PropCount:cardinal;   //Anzahl der dynamischen Komponenten

       Content:array[0..16737] of TPropContent;

end;

Dich interessiert davon das Array Content[0..Propcount-1]. Und in jedem Element des Arrays hlst du dir RecordData. Das ist ein Zeiger auf einen Zeiger auf die RTTI der dynamischen Komponente aus deiner Klasse. Und wenn dort das erste Byte $0A ist, dann ist die dynamische Komponente ein String (Du kannst auch mit den Konstanten aus der TypeInfo arbeiten tkString=10).
Jetzt weist du dass diese dynamische Komponente ein String ist und du nimmst dir Position, addierst den Wert zu self und hast deinen String.
Und jetzt musst du den Inhalt überprüfen, wie Phoenix sagte.

**SirThornberry**

Eine Instanz ist eigentlich ein Pointer auf den Bereich wo die Daten für die Klasse liegen.
Wenn du also weißt an welchem Offset der String liegt brauchst du einfach nur auf die Instanzvariable den Offset addieren, die erhaltene Adresse auf einen PString casten und dann zu ändern.

bei

markieren

Delphi-Quellcode:

			type 

  TmyTest = class(TObject) 

  private 

    sTest: string; 

  public 

    constructor Create; 

    function getTest: string; 

  end;

kommst du so an "sTest":

markieren

Delphi-Quellcode:

			var

  lMyTest : TmyTest;

begin

  lMyTest := TmyTest.Create();

  PString(Cardinal(lMyTest) + Cardinal(TmyTest.InstanceSize) - sizeof(string))^ := 'neuer Wert';

[Edit]
TmyTest.InstanceSize auf Cardinal gecastet um Warnung weg zu bekommen
[/Edit]

**Hawkeye219**

Hallo MaBuSE,

unter gewissen Voraussetzungen kann eine

shadow class den Zugriff ermöglichen.

Gruß Hawkeye

**MaBuSE**

Danke an Alle !!!

@sirius: ich muß mal schauen wie weit ich hier mit rtti komme -> morgen

Zitat von SirThornberry:

Eine Instanz ist eigentlich ein Pointer auf den Bereich wo die Daten für die Klasse liegen.
Wenn du also weißt an welchem Offset der String liegt brauchst du einfach nur auf die Instanzvariable den Offset addieren, die erhaltene Adresse auf einen PString casten und dann zu ändern.
...

Die Test Klasse ist stark vereinfacht. Ich wollte kein zu kompliziertes Beispiel.
Das Objekt, um das es geht hat ein paar hundert private Variablen, Funktionen und Proceduren. und noch ein mal ein paar hundert Dinge in protected, public und published. Das macht das ganze etwas schwerer.

@Hawkeye: Deine Lösung sieht vielversprechend aus. Ich werde das mal morgen im Büro testen

Vieleicht gibt es ja noch mehr Ideen

**negaH**

Hast du den Source der Klasse ? Wenn ja kopiere deren Deklaration, nenne sie um, schmeiße alle Methoden usw. raus bis nur noch die privaten Felder in deiner neuen Deklaration drinnen stehen. Beim Zugriff auf diese Felder castest du dein Object zum neuen Klassentyp. Das sähe so aus:

markieren

Delphi-Quellcode:

			type

  TXYClassCracker = class(TXYClassAnchor)

  private

    FField: ..... 

  end;

procedure Test;

begin

  TXYClassCracker(Object).FField := ....;

end;

Du deklarierst quasi eine 1 zu 1 Kopie deiner Klasse auf die du später illegalen Zugriff erlangen möchtest. Letzendlich geht es dabei nur darum das der Compiler die richtigen Zeigeroffsets auf die Felder des Objectes errechnen kann.

Gruß Hagen

schreibender Zugriff auf private Variablen ?

schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Re: schreibender Zugriff auf private Variablen ?

Forumregeln

Hawkeye219 Registriert seit: 18. Feb 2006 Ort: Stolberg 2.227 Beiträge Delphi 2010 Professional	#8 Re: schreibender Zugriff auf private Variablen ? 6. Nov 2007, 18:06 Hallo MaBuSE, unter gewissen Voraussetzungen kann eine shadow class den Zugriff ermöglichen. Gruß Hawkeye
	Zitat