RCx-Verschlüsselung

[himitsu]

zu Code-Library -> Algorithmen -> RC4-Verschlüsselung

Hier noch die Unicode-Anpassungen (der Unit von CalganX)

(dieser ist aber ein ganz schön fleißiger Overload-Nutzer, auch dann, wenn es nicht nötig ist :lol: )

Delphi-Quellcode:

{
Copyright:      2002 Hagen Reddmann
Author:         Hagen Reddmann, HaReddmann bei T-Online punkt de
Remarks:        All rights reserved
Version:        open source, developed on D5
Description:    derivate of RC4 stream cipher with internal cipher feedback and stronger keysetup
                includes secure one way pseudo random number generator
}

unit RCx;
{$A+,B-,C-,D-,E-,F-,G+,H+,I-,J+,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U+,V+,W-,X+,Y-,Z1}

interface

type
  TRCxContext = record
    D: array[Byte] of Byte;
    I,J,F: Byte;
  end;

procedure RCxInit  (var RCx: TRCxContext; const Key; KeySize: Integer); overload;
procedure RCxInit  (var RCx: TRCxContext; const Key: AnsiString); overload;
procedure RCxInit  (var RCx: TRCxContext; const Key: WideString); overload;
procedure RCxEncode(var RCx: TRCxContext; const Source; var Dest; Count: Integer); overload;
function  RCxEncode(var RCx: TRCxContext; const Value: AnsiString): AnsiString; overload;
function  RCxEncode(var RCx: TRCxContext; const Value: WideString): WideString; overload;
procedure RCxDecode(var RCx: TRCxContext; const Source; var Dest; Count: Integer); overload;
function  RCxDecode(var RCx: TRCxContext; const Value: AnsiString): AnsiString; overload;
function  RCxDecode(var RCx: TRCxContext; const Value: WideString): WideString; overload;
procedure RCxDone  (var RCx: TRCxContext);

// all in one encode/decode
function  RCxEncode(const Value, Password: AnsiString): AnsiString; overload;
function  RCxEncode(const Value, Password: WideString): WideString; overload;
function  RCxDecode(const Value, Password: AnsiString): AnsiString; overload;
function  RCxDecode(const Value, Password: WideString): WideString; overload;

// random number generator based on RCx
procedure RCxSeed(const Seed; SeedSize: Integer); overload;
procedure RCxSeed(const Seed: AnsiString); overload;
procedure RCxSeed(const Seed: WideString); overload;
procedure RCxRandomize; overload;
function  RCxRandom         (Range: Cardinal = 0): Cardinal;
function  RCxRandomString   (Length: Integer): AnsiString;
procedure RCxGetRandomString(Length: Integer; var Result: AnsiString); overload;
procedure RCxGetRandomString(Length: Integer; var Result: WideString); overload;

implementation

type
  PByteArray = ^TByteArray;
  TByteArray = array[0..MaxInt -1] of Byte;

procedure RCxInit(var RCx: TRCxContext; const Key; KeySize: Integer);
var
  R,S,T,K: Byte;
  L: Integer;
  M: array[Byte] of Byte;
begin
  with RCx do
  try
    L := 0;
    for S := 0 to 255 do
    begin
      D[S] := S;
      M[S] := TByteArray(Key)[S mod KeySize] xor L;
      L := (L + M[S] * 257) mod MaxInt +1;
    end;
    I := 0;
    J := 0;
    R := L;
    F := L shr 8;
    for S := 0 to 255 do
    begin
      Inc(R, D[S] + M[S]);
      T    := D[S];
      D[S] := D[R];
      D[R] := T;
    end;
  finally
    R := 0;
    S := 0;
    T := 0;
    L := 0;
    FillChar(M, SizeOf(M), 0);
  end;
end;

procedure RCxInit(var RCx: TRCxContext; const Key: AnsiString);
begin
  RCxInit(RCx, Pointer(Key)^, Length(Key));
end;

procedure RCxInit(var RCx: TRCxContext; const Key: WideString);
begin
  RCxInit(RCx, Pointer(Key)^, Length(Key) * 2);
end;

procedure RCxDone(var RCx: TRCxContext);
begin
  FillChar(RCx, SizeOf(RCx), 0);
end;

procedure RCxEncode(var RCx: TRCxContext; const Source; var Dest; Count: Integer);
var
  S: TByteArray absolute Source;
  O: TByteArray absolute Dest;
  C: Integer;
  T,K: Byte;
begin
  with RCx do
    for C := 0 to Count -1 do
    begin
      Inc(I);
      T := D[I];
      Inc(J, T);
      D[I] := D[J] xor F;
      D[J] := T - F;
      Inc(T, D[I]);

      K := S[C];
      O[C] := K xor D[T];
      F := F xor K;
    end;
end;

procedure RCxDecode(var RCx: TRCxContext; const Source; var Dest; Count: Integer);
var
  S: TByteArray absolute Source;
  O: TByteArray absolute Dest;
  C: Integer;
  T,K: Byte;
begin
  with RCx do
    for C := 0 to Count -1 do
    begin
      Inc(I);
      T := D[I];
      Inc(J, T);
      D[I] := D[J] xor F;
      D[J] := T - F;
      Inc(T, D[I]);

      K := S[C] xor D[T];
      O[C] := K;
      F := F xor K;
    end;
end;

function RCxEncode(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxEncode(RCx, Value[1], Result[1], Count);
end;

function RCxEncode(var RCx: TRCxContext; const Value: WideString): WideString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxEncode(RCx, Value[1], Result[1], Count * 2);
end;

function RCxDecode(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxDecode(RCx, Value[1], Result[1], Count);
end;

function RCxDecode(var RCx: TRCxContext; const Value: WideString): WideString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxDecode(RCx, Value[1], Result[1], Count * 2);
end;

function RCxEncode(const Value, Password: AnsiString): AnsiString;
var
  RCx: TRCxContext;
begin
  RCxInit(RCx, Password);
  try
    Result := RCxEncode(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxEncode(const Value, Password: WideString): WideString;
var
  RCx: TRCxContext;
begin
  RCxInit(RCx, Password);
  try
    Result := RCxEncode(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxDecode(const Value, Password: AnsiString): AnsiString;
var
  RCx: TRCxContext;
begin
  RCxInit(RCx, Password);
  try
    Result := RCxDecode(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxDecode(const Value, Password: WideString): WideString;
var
  RCx: TRCxContext;
begin
  RCxInit(RCx, Password);
  try
    Result := RCxDecode(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

var
  FRCxRegister: TRCxContext;

procedure RCxSeed(const Seed; SeedSize: Integer);
begin
  RCxInit(FRCxRegister, Seed, SeedSize);
end;

procedure RCxSeed(const Seed: AnsiString);
begin
  RCxSeed(Pointer(Seed)^, Length(Seed));
end;

procedure RCxSeed(const Seed: WideString);
begin
  RCxSeed(Pointer(Seed)^, Length(Seed) * 2);
end;

procedure RCxRandomize;
var
  Tick: Cardinal;
begin
  Tick := GetTickCount;
  FRCxRegister.F := Tick;
  FRCxRegister.I := Tick shr 8;
  FRCxRegister.J := Tick shr 16;
  RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
end;

function RCxRandom(Range: Cardinal): Cardinal;
type
  PCardinal = ^Cardinal;
begin
  RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
  Result := PCardinal(@FRCxRegister.D)^;
  if Range > 1 then Result := Result mod Range;
end;

function RCxRandomString(Length: Integer): AnsiString;
begin
  RCxGetRandomString(Length, Result);
end;

procedure RCxGetRandomString(Length: Integer; var Result: AnsiString); 
var
  I: Integer;
begin
  SetLength(Result, Length);
  for I := 1 to Length do
  begin
    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
    Result[I] := AnsiChar(FRCxRegister.D[0]);
  end;
end;

procedure RCxGetRandomString(Length: Integer; var Result: WideString);
//begin
//  SetLength(Result, Length);
//  for I := 1 to Length do
//  begin
//    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
//    W := FRCxRegister.D[0];
//    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
//    Result[I] := WideChar((Word(FRCxRegister.D[0]) shl 8) or W);
//  end;
//end;
var
  I: Integer;
  W: Word;
begin
  W := 0;
  SetLength(Result, Length);
  for I := 1 to Length * 2 do
  begin
    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
    if Odd(I) then W := FRCxRegister.D[0]
    else Result[I div 2] := WideChar((Word(FRCxRegister.D[0]) shl 8) or W);
  end;
end;

const
  FRCxSeed: TGUID = '{F4D35205-2B59-42B0-8B8F-239855B6DD2B}';

initialization
  RCxSeed(FRCxSeed, SizeOf(FRCxSeed));

finalization

end.

:!: Zu beachten sei, daß das Ergebnis unter Unicode natürlich ein Anderes ist, wie unter Ansi, da hier ja Byteweise verschlüsselt wird.
Wenn man also z.B. auch in Delphi 2009 das selbe Ergebnis haben möchte/muß, wie unter eine früheren Delphi-Version (bei Verwendung von String), dann muß man selber seine String-Variablen geziehlt als AnsiString definieren.

[tags]RC4 RCx[/tags]

[gammatester]

Vielleicht solltest Du den Titel ändern, denn RC4 ist das mit Sicherkeit nicht. Laut Kommemtar noch nicht mal RC5, sondern ein modifizierter RC5-Eigenbau.

[himitsu]

noar, hatte diesen Thread halt nach dem Original-Thread benannt :angel2:

[Zacherl]

Ahjo das ist auch die modifizierte RCx Variante von Hagen.

[negaH]

Es ist eine veränderte Version vom RC4. Die erste Veränderung ist eine zusätzliche XOR Operation innerhalb der originalen RC4 Schleife um ein 1 Bytes Feedback Register in den internen Status des RC4 einzuarbeiten. Die zweite Veränderung ist ein 1 Bytes Feedback Register bei der Manipulation des Datenstroms. Beidesmal wird XOR als Operation benutzt und ich habe dabei darauf geachtet das die originale Funktionsweise des RC4 nicht negativ beeinflusst wird wir aber denoch eine positove Verbesserung des originalen RC4 erhalten. Durch die erste Veränderung wird das Gesamtverhalten des RC4 nicht wesentlich verändert. Erst durch die zweite Änderung verändert sich Wesentliches an der Nutzung des Algorithmus. Denn nun benötigen wir für die Ver- und Entschlüsselung zwei unterschiedliche Funktionen. Das ist ungewöhnlich für einen Streamcipher und liegt darin begründet das dieser RCx einen Feedback Ciphermode benutzt.
Durch die Benutzung eines Feedbackregisters werden die Datenströme, eg. die Abhängigkeiten der einzelnen Datenbytes zueindern, verändert und besser in den internen RC4 Status eingearbeitet, was im Original RC4 nicht der Fall ist.
Die dritte Änderung betrifft das Keyshuffling in der Schlüsselinitialisierung. Der wesentlichste Unterschied ist das im RCx dieses Keyshuffling komplexer ist und mathematisch im modularen Ring zu den Primzahlen 257 und MaxInt arbeitet. Auch dies ist im original RC5 nicht der Fall und ich denke das ich damit auf die Weiterentwicklungen der Kryptographie in diesem Bereich reagiert habe.

Ergo: RCx ist RC4 in abgewandelter Form, wobei darauf geachtet wurde das die Kernidee des RC4 nicht negativ verändert wird, sondern an anderen Stellen auf die Weiterentwicklung der Kryptographie reagiert wird. Mit RC5 hat RCx garnichts zu tun, RC5 ist ja auch ein Blockcipher.

Wer die Auswirkungen dieser Änderungen überprüfen möchte verschlüsselt mit RCx und RC4 mal verschiedene Datenströme. Als erstes zb. die Nachrichten "0123456789", "a123456789", "b123456789", "xx23456789", "01234x6789" und vergleicht den Output. Dann mehrmals die Nachricht Zufallsbyte + "123456789". Man wird erkennen das RCx im Ouput wesentlich stärkere Veränderungen bewirkt und das das Einarbeiten eines Zufallsalts am Anfang der Nachricht beim RCx auch eine Wirkung auf den kompletten Output hat ganz im Gegensatz zu RC4.

Gruß Hagen

PS: der Kommentar im Source das es RC5 wäre stammt nicht von mir !

[himitsu]

Upps, ein kleiner Kopierfehler (es wurde nicht koppiert und zufällig eine "noch" falsche Version hier eingefügt.

Im Interface müßte beim zweiten RCxGetRandomString das AnsiString in WideString getauscht werden
und das Wichtigere: In der Implementation fehlten beide RCxGetRandomString ganz. :shock:

> wurde oben [#1] editiert

[Shark99]

Bei mir kompiliert der Code unter Delphi 5 nicht.

Bekomme diese Fehlermeldung:

[Error] rcx.pas(190): Ambiguous overloaded call to 'RCxInit'

Delphi-Quellcode:

function RCxEncode(const Value, Password: AnsiString): AnsiString; 
var
  RCx: TRCxContext;
begin
  RCxInit(RCx, Password); // das ist die Fehlerzeile
  try
    Result := RCxEncode(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

Ich verstehe es nicht ganz, weil Password hier Ansistring ist und RCxInit so definiert ist:

Delphi-Quellcode:

procedure RCxInit(var RCx: TRCxContext; const Key; KeySize: Integer); overload;
procedure RCxInit(var RCx: TRCxContext; const Key: AnsiString); overload;
procedure RCxInit(var RCx: TRCxContext; const Key: WideString); overload;

Also ist der zweite Parameter eindeutig unterscheidbar und die RCxInit(var RCx: TRCxContext; const Key: AnsiString); version aufgerufen werden sollte. Delphi meckert dennoch.

[himitsu]

Zitat:

Zitat von negaH

PS: der Kommentar im Source das es RC5 wäre stammt nicht von mir !

Hab's mal auf RC4 geändert ... sollte wohl besser passen.

@Shark99: Es kann sein, daß Delphi5 in Bezug auf das Überladen (overload) noch einige Kinderkrankheiten aufweist.

Wenn ich mich jetzt nicht vertippt hab, dann sollte dieses eine Version ohne Overloading sein,
allerdings mußt du da vermutlich deinen Code etwas anpassen, da hier über den Funktionsnamen und nicht mehr über Parameter unterschieden wird.

Delphi-Quellcode:

{
Copyright:      2002 Hagen Reddmann
Author:         Hagen Reddmann, HaReddmann bei T-Online punkt de
Remarks:        All rights reserved
Version:        open source, developed on D5
Description:    derivate of RC4 stream cipher with internal cipher feedback and stronger keysetup
                includes secure one way pseudo random number generator
}

unit RCx;
{$A+,B-,C-,D-,E-,F-,G+,H+,I-,J+,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U+,V+,W-,X+,Y-,Z1}

interface

type
  TRCxContext = record
    D: array[Byte] of Byte;
    I,J,F: Byte;
  end;

procedure RCxInit   (var RCx: TRCxContext; const Key; KeySize: Integer);
procedure RCxInitA  (var RCx: TRCxContext; const Key: AnsiString);
procedure RCxInitW  (var RCx: TRCxContext; const Key: WideString);
procedure RCxEncode (var RCx: TRCxContext; const Source; var Dest; Count: Integer);
function  RCxEncodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
function  RCxEncodeW(var RCx: TRCxContext; const Value: WideString): WideString;
procedure RCxDecode (var RCx: TRCxContext; const Source; var Dest; Count: Integer);
function  RCxDecodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
function  RCxDecodeW(var RCx: TRCxContext; const Value: WideString): WideString;
procedure RCxDone   (var RCx: TRCxContext);

// all in one encode/decode
function  RCxEncode_A(const Value, Password: AnsiString): AnsiString;
function  RCxEncode_W(const Value, Password: WideString): WideString;
function  RCxDecode_A(const Value, Password: AnsiString): AnsiString;
function  RCxDecode_W(const Value, Password: WideString): WideString;

// random number generator based on RCx
procedure RCxSeed (const Seed; SeedSize: Integer);
procedure RCxSeedA(const Seed: AnsiString);
procedure RCxSeedW(const Seed: WideString);
procedure RCxRandomize;
function  RCxRandom       (Range: Cardinal = 0): Cardinal;
function  RCxRandomStringA(Length: Integer): AnsiString;
function  RCxRandomStringW(Length: Integer): WideString;

implementation

type
  PByteArray = ^TByteArray;
  TByteArray = array[0..MaxInt -1] of Byte;

procedure RCxInit(var RCx: TRCxContext; const Key; KeySize: Integer);
var
  R,S,T,K: Byte;
  L: Integer;
  M: array[Byte] of Byte;
begin
  with RCx do
  try
    L := 0;
    for S := 0 to 255 do
    begin
      D[S] := S;
      M[S] := TByteArray(Key)[S mod KeySize] xor L;
      L := (L + M[S] * 257) mod MaxInt +1;
    end;
    I := 0;
    J := 0;
    R := L;
    F := L shr 8;
    for S := 0 to 255 do
    begin
      Inc(R, D[S] + M[S]);
      T    := D[S];
      D[S] := D[R];
      D[R] := T;
    end;
  finally
    R := 0;
    S := 0;
    T := 0;
    L := 0;
    FillChar(M, SizeOf(M), 0);
  end;
end;

procedure RCxInitA(var RCx: TRCxContext; const Key: AnsiString);
begin
  RCxInit(RCx, Pointer(Key)^, Length(Key));
end;

procedure RCxInitW(var RCx: TRCxContext; const Key: WideString);
begin
  RCxInit(RCx, Pointer(Key)^, Length(Key) * 2);
end;

procedure RCxDone(var RCx: TRCxContext);
begin
  FillChar(RCx, SizeOf(RCx), 0);
end;

procedure RCxEncode(var RCx: TRCxContext; const Source; var Dest; Count: Integer);
var
  S: TByteArray absolute Source;
  O: TByteArray absolute Dest;
  C: Integer;
  T,K: Byte;
begin
  with RCx do
    for C := 0 to Count -1 do
    begin
      Inc(I);
      T := D[I];
      Inc(J, T);
      D[I] := D[J] xor F;
      D[J] := T - F;
      Inc(T, D[I]);

      K := S[C];
      O[C] := K xor D[T];
      F := F xor K;
    end;
end;

procedure RCxDecode(var RCx: TRCxContext; const Source; var Dest; Count: Integer);
var
  S: TByteArray absolute Source;
  O: TByteArray absolute Dest;
  C: Integer;
  T,K: Byte;
begin
  with RCx do
    for C := 0 to Count -1 do
    begin
      Inc(I);
      T := D[I];
      Inc(J, T);
      D[I] := D[J] xor F;
      D[J] := T - F;
      Inc(T, D[I]);

      K := S[C] xor D[T];
      O[C] := K;
      F := F xor K;
    end;
end;

function RCxEncodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxEncode(RCx, Value[1], Result[1], Count);
end;

function RCxEncodeW(var RCx: TRCxContext; const Value: WideString): WideString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxEncode(RCx, Value[1], Result[1], Count * 2);
end;

function RCxDecodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxDecode(RCx, Value[1], Result[1], Count);
end;

function RCxDecodeW(var RCx: TRCxContext; const Value: WideString): WideString;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  RCxDecode(RCx, Value[1], Result[1], Count * 2);
end;

function RCxEncode_A(const Value, Password: AnsiString): AnsiString;
var
  RCx: TRCxContext;
begin
  RCxInitA(RCx, Password);
  try
    Result := RCxEncodeA(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxEncode_W(const Value, Password: WideString): WideString;
var
  RCx: TRCxContext;
begin
  RCxInitW(RCx, Password);
  try
    Result := RCxEncodeW(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxDecode_A(const Value, Password: AnsiString): AnsiString;
var
  RCx: TRCxContext;
begin
  RCxInitA(RCx, Password);
  try
    Result := RCxDecodeA(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

function RCxDecode_W(const Value, Password: WideString): WideString;
var
  RCx: TRCxContext;
begin
  RCxInitW(RCx, Password);
  try
    Result := RCxDecodeW(RCx, Value);
  finally
    RCxDone(RCx);
  end;
end;

var
  FRCxRegister: TRCxContext;

procedure RCxSeed(const Seed; SeedSize: Integer);
begin
  RCxInit(FRCxRegister, Seed, SeedSize);
end;

procedure RCxSeedA(const Seed: AnsiString);
begin
  RCxSeed(Pointer(Seed)^, Length(Seed));
end;

procedure RCxSeedW(const Seed: WideString);
begin
  RCxSeed(Pointer(Seed)^, Length(Seed) * 2);
end;

procedure RCxRandomize;
var
  Tick: Cardinal;
begin
  Tick := GetTickCount;
  FRCxRegister.F := Tick;
  FRCxRegister.I := Tick shr 8;
  FRCxRegister.J := Tick shr 16;
  RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
end;

function RCxRandom(Range: Cardinal): Cardinal;
type
  PCardinal = ^Cardinal;
begin
  RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
  Result := PCardinal(@FRCxRegister.D)^;
  if Range > 1 then Result := Result mod Range;
end;

procedure RCxRandomStringA(Length: Integer; var Result: AnsiString);
var
  I: Integer;
begin
  SetLength(Result, Length);
  for I := 1 to Length do
  begin
    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
    Result[I] := AnsiChar(FRCxRegister.D[0]);
  end;
end;

procedure RCxRandomStringW(Length: Integer; var Result: WideString);
//begin
//  SetLength(Result, Length);
//  for I := 1 to Length do
//  begin
//    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
//    W := FRCxRegister.D[0];
//    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
//    Result[I] := WideChar((Word(FRCxRegister.D[0]) shl 8) or W);
//  end;
//end;
var
  I: Integer;
  W: Word;
begin
  W := 0;
  SetLength(Result, Length);
  for I := 1 to Length * 2 do
  begin
    RCxEncode(FRCxRegister, FRCxRegister.D, FRCxRegister.D, SizeOf(FRCxRegister.D));
    if Odd(I) then W := FRCxRegister.D[0]
    else Result[I div 2] := WideChar((Word(FRCxRegister.D[0]) shl 8) or W);
  end;
end;

const
  FRCxSeed: TGUID = '{F4D35205-2B59-42B0-8B8F-239855B6DD2B}';

initialization
  RCxSeed(FRCxSeed, SizeOf(FRCxSeed));

finalization

end.

[thepaine91]

Super das sich schon jemand die Arbeit gemacht hat das ganze Unicode fähig zu machen, =) war grad dabei das selbst in Angriff zu nehmen....

Danke an himitsu.

[Luckie]

Das sieht jetzt aber noch schlimmer aus, als vorher:

Delphi-Quellcode:

procedure RCxInit (var RCx: TRCxContext; const Key; KeySize: Integer);
procedure RCxInitA (var RCx: TRCxContext; const Key: AnsiString);
procedure RCxInitW (var RCx: TRCxContext; const Key: WideString);
procedure RCxEncode (var RCx: TRCxContext; const Source; var Dest; Count: Integer);
function RCxEncodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
function RCxEncodeW(var RCx: TRCxContext; const Value: WideString): WideString;
procedure RCxDecode (var RCx: TRCxContext; const Source; var Dest; Count: Integer);
function RCxDecodeA(var RCx: TRCxContext; const Value: AnsiString): AnsiString;
function RCxDecodeW(var RCx: TRCxContext; const Value: WideString): WideString;
procedure RCxDone (var RCx: TRCxContext);

// all in one encode/decode
function RCxEncode_A(const Value, Password: AnsiString): AnsiString;
function RCxEncode_W(const Value, Password: WideString): WideString;
function RCxDecode_A(const Value, Password: AnsiString): AnsiString;
function RCxDecode_W(const Value, Password: WideString): WideString;

// random number generator based on RCx
procedure RCxSeed (const Seed; SeedSize: Integer);
procedure RCxSeedA(const Seed: AnsiString);
procedure RCxSeedW(const Seed: WideString);
procedure RCxRandomize;
function RCxRandom (Range: Cardinal = 0): Cardinal;
function RCxRandomStringA(Length: Integer): AnsiString;
function RCxRandomStringW(Length: Integer): WideString;

Das schreit ja gerade zu nach einer Klasse.