RC4 und Delphi.Net

[skyware]

Hallo zusammen!

Interessiert habe ich die RC4 Beiträge gelesen...hab dann die vorgeschlagenen
Funktionen auch gleich ausprobiert.
Unter Delphi 6 läuft alles einwandfrei :-D
Doch unter Delphi 8.NET hat der Compiler keine Freude am Datentype "PByteArray" :shock:
Hat jemand ne Ahnung wie man diesen Code ändern muss damit er auch .NET kompatibel ist? :?:

Danke im voraus :-D

Delphi-Quellcode:

procedure RC4Init(var RC4: TRC4Context; const Key: String);
var
  R,S,T,K: Byte;
  U,L: Integer;
begin
  L := Length(Key);
  with RC4 do
  begin
    I := 0; 
    J := 0;
    for S := 0 to 255 do D[S] := S;
    R := 0;
    U := 0;
    for S := 0 to 255 do
    begin
      if U < L then K := PByteArray(Key)[U] else K := 0;
      Inc(U);
      if U >= L then U := 0;

      Inc(R, D[S] + K);
      T    := D[S];
      D[S] := D[R];
      D[R] := T;
    end;
  end;
end;

[Robert Marquardt]

Ein Byte(Key[U+1]) sollte es tun.

[Robert_G]

Zitat:

Zitat von skyware

Doch unter Delphi 8.NET hat der Compiler keine Freude am Datentype "PByteArray" :shock:

PByteArray dürfte wohl ein Pointer auf einen ByteArray darstellen. Das wird die CLR nie schlucken. ;)

Zitat:

Zitat von Robert Marquardt

Ein Byte(Key[U+1]) sollte es tun.

Ich glaube nicht....
So bekommst du wenigstens einen byte[], das dürfte eigentlich die größte Hürde gewesen sein. ;)

Delphi-Quellcode:

var
  ...
  SomeByteArray: array of byte;
begin
  ...
  SomeByteArray := Convert.FromBase64String(Key);
  ...
end;

[skyware]

Hallo Robert,

danke für die prompte Antwort! :-D
Es lässt sich nun kompilieren, hab den Code nochmals angeschaut. Das heisst nun also
das in "Byte(AKey[xU+1])" das xU+1 Zeichen (Char) von AKey als Byte gelesen wird? :gruebel:

Nun versteht ich aber folgende Zeile nicht mehr:
"TByteArray(Dest)[xS] := TByteArray(ASource)[xS] xor FD[xT];"
die lässt sich nämlich auch nicht kompilieren :wall:
Und mit "Bytes" scheints auch nicht zu gehen... :gruebel:
Was muss hier getan werden, und was passiert hier genau?

Delphi-Quellcode:

procedure RC4Code(var ARC4: TRC4Context; const ASource; var Dest; ACount: Integer);
var 
  xS : Integer;
  xT : Byte;

  xtest : byte;
begin
  with ARC4 do
    for xS := 0 to ACount -1 do
    begin
      Inc(FI);
      xT := FD[FI];
      Inc(FJ, xT);
      FD[FI] := FD[FJ];
      FD[FJ] := xT;
      Inc(xT, FD[FI]);
      {$IFDEF CLR}
      TByteArray(Dest)[xS] := TByteArray(ASource)[xS] xor FD[xT];
      {$ELSE}
      TByteArray(Dest)[xS] := TByteArray(ASource)[xS] xor FD[xT];
      {$ENDIF}
    end;
end;

[Robert_G]

Lass dir einen Tip geben. Schließe D8 und mache dir ein schönes Wochenende.
D8 hat nur unwesentlich mehr mit .Net zu tun als es D7 hatte. Willst du irgendwann mal in einer Delphi IDE .Net programmieren, würde ich dir C# in Delphi2005 empfehlen. :lol:
Delphi.Net ermöglicht einfach keinen Code, der aussieht wie .Net. ;) (Es hat auch unter .Net noch Forward deklarationen, der Compiler kann immer noch nicht gleichnamige Typen & Objekte unterscheiden, usw. )
Solch ein mittelalterlicher Compiler passt einfach nicht zu .Net. Warum sollte auch der Entwickler ekligen Code schreiben müssen nur damit der Compiler alles in einem Durchlauf machen kann. :roll:
In spätestens 2 Monaten liegt dein D8 dort, wo es bei fast jedem D8-Besitzer liegt: Im Schrank und staubt ein.

[skyware]

neeeee möcht jetzt nicht aufgeben! :-D
sind nur 2 zeilen die laufen müssen, das wird schon
noch klappen, möchte delphi8 nicht in den schrank verbannen! :shock:

[LarsMiddendorf]

Deklarier die Funktion doch als unsafe, dann kannst du Zeiger und vermutlich auch PByteArray nutzen.

[Robert Marquardt]

Die originale Umtypung ist im Prinzip das Gleiche wie PChar().
Der wichtigste Unterschied zwischen einem PChar und einem string ist das der string ab 1 adessiert wird und der PChar ab 0.
Byte(Key[U+1]) heisst also das der Char aus dem string geholt wird (+1) und dann in ein Byte umgetype wird.
Das Original typt den string zu einem Byte array um und holt dann das Byte.

[skyware]

Hallo zusammen,

danke für Eure Unterstützung, leider hab ich immer noch 2 Problemchen
die ich seit gestern nicht lösen konnte, bin am verzweifeln :wall:
Die Codezeilen die mir noch Probleme bereichen sind mit "//todo" markiert.
Hab scho diverses versucht mit Byte casten, mit Convert.GetBase64FromString etc.,
hat alles nichts geholfen :pale:
Please help :gruebel:

ps: Lars, unsafe Code möcht ich eigentlich vermeiden :-D

Delphi-Quellcode:

unit HTFunctions_Crypt_RC4;

interface

uses
  {$IFDEF CLR}Borland.Vcl.SysUtils{$ELSE}SysUtils{$ENDIF};


function  RC4Encode(const AString, AKey: string): string;
function  RC4Decode(const AString, AKey: string): string;


implementation

type
  TRC4Context = record
    FD  : array[Byte] of Byte;
    FI,
    FJ  : Byte;
  end;

{ RC4Init:
-------------------------------------------------------------------------------}
procedure RC4Init(var ARC4: TRC4Context; const AKey: String);
var
  xR,
  xS,
  xT,
  xK : Byte;
  xU,
  xL : Integer;
begin
  xL := Length(AKey);
  with ARC4 do
  begin
    FI := 0;
    FJ := 0;
    for xS := 0 to 255 do FD[xS] := xS;
    xR := 0;
    xU := 0;
    for xS := 0 to 255 do
    begin
      {$IFDEF CLR}
      if xU < xL then xK := Byte(AKey[xU+1]) else xK := 0;
      {$ELSE}
      if xU < xL then xK := PByteArray(AKey)[xU] else xK := 0;
      {$ENDIF}
      Inc(xU);
      if xU >= xL then xU := 0;

      Inc(xR, FD[xS] + xK);
      xT     := FD[xS];
      FD[xS] := FD[xR];
      FD[xR] := xT;
    end;
  end;
end;

{ RC4Code:
-------------------------------------------------------------------------------}
procedure RC4Code(var ARC4: TRC4Context; const ASource; var Dest; ACount: Integer);
var 
  xS : Integer;
  xT : Byte;
begin
  with ARC4 do
    for xS := 0 to ACount -1 do
    begin
      Inc(FI);
      xT := FD[FI];
      Inc(FJ, xT);
      FD[FI] := FD[FJ];
      FD[FJ] := xT;
      Inc(xT, FD[FI]);
      {$IFDEF CLR}
      //todo
      TByteArray(Dest)[xS] := TByteArray(ASource)[xS] xor FD[xT];
      {$ELSE}
      TByteArray(Dest)[xS] := TByteArray(ASource)[xS] xor FD[xT];
      {$ENDIF}
    end;
end;

{ RC4Done:
-------------------------------------------------------------------------------}
procedure RC4Done(var ARC4: TRC4Context);
begin
  //todo
  FillChar(ARC4, SizeOf(ARC4), 0);
end;

{ RC4Encode:
-------------------------------------------------------------------------------}
function RC4Encode(const AString, AKey: string): string;
var
  xRC4 : TRC4Context;
begin
  SetLength(Result, Length(AString));
  RC4Init(xRC4, AKey);
  RC4Code(xRC4, AString[1], Result[1], Length(AString));
  Rc4Done(xRC4);
end;

{ RC4Decode:
-------------------------------------------------------------------------------}
function RC4Decode(const AString, AKey: string): string;
var
  xRC4 : TRC4Context;
begin
  SetLength(Result, Length(AString));

  RC4Init(xRC4, AKey);
  RC4Code(xRC4, AString[1], Result[1], Length(AString));
  Rc4Done(xRC4);
end;


end.

[Robert_G]

Zitat:

Zitat von skyware

ps: Lars, unsafe Code möcht ich eigentlich vermeiden :-D

Du gibst dir aber alle Mühe unsafe Code zu erzeugen. ;)
Schließlich benutzt du die VCL.Net! :shock: Die ist vollgestopft mit unsafe Code.
Ich sag's nochmal: Schließe D8 und mache dir 'nen schönen Sonntag (Den Samstag hast du ja schon mit D8 verplempert ;) ).
Was du da versuchst ist keine Portierung zu .Net, es ist nur eine Portierung zur VCL.Net.