Zufallszahlengenerator?

[urs.liska]

Der Algorithmus, der verwendet wird, führt immer irgendwelche Operationen mit dem zuletzt verwendeten Wert durch. Ich glaube mich zu erinnern, in der Schule gelernt zu haben, dass man z.B. von einer Zahl zwischen 0 und 1 das Quadrat ermittelt und dann irgendwelche Stellen vorne (oder hinten?) abschneidet. Wenn man das immer wieder macht, kommt man nie auf Null oder Eins, sondern es geht immer weiter.
Der Punkt ist aber (egal wie es nun genau gemacht wird): wenn am Anfang dieselbe Zahl steht, gibt es auch immer die gleiche Folge von "Zufallszahlen" (Probiere es aus, indem du RandSeed eine beliebige Zahl zuweist und dann 50 mal Random aufrufst. Wenn du das mehrmals mit der gleichen Ausgangszahl machst, bekommst Du immer dieselbe Folge von Zufallszahlen). Daher nimmt Randomize die Systemzeit, um sie RandSeed zuzuweisen (ob nun 1 zu 1 oder irgendwie umgewandelt, weiß ich nicht, spielt auch keine Rolle); dadurch wird ein unvorhersehbarer Wert als Ausgangspunkt ermittelt, so dass die Ergebnisse in den meisten Fällen ausreichend 'zufällig' sein dürften.

[Meflin]

wow, so genau wusst ichs nicht!
ich hab nur gelesen, dass die funktion
nie zur verschlüsselung o.ä. sicherheitsrelevanten
operationen verwendet werden sollte, da sie
eben nicht zufällig genug ist. wenn ich den artikel wieder finde,
kann ich gerne mal zitieren!

[braingrenade]

jo , aber ich brauch auch keinen richtigen zufall , eigentlich brauch ich den Algorythmus für eine Verschlüsselung , damit ich z.b. aus zwei Zahlen möglichst viele andere machen kann ,damit ich aus einem Schlüssel einen Schlüsselstrom machen kann.

[negaH]

Es gibt Hardware basierte Zufallsgeneratoren die physikalisch echten Zufall erzeugen. Ich selber habe zwei Wege schon programmiert
1.) echter Zufall aus dem Indernett, ja das gibt es. Diese Server stellen per HTML die Möglichkeit zur Verfügung Zufall zu downloaden der durch Radioaktiven Zerfall erzeugt wurde.
2.) auf jeder neueren Geldkarte, also die Bankkarten mit Chip, ist ein Hardwarezufallsgenerator integriert. Diesen kann man relativ einfach per PC/SC Schnittstelle ansprechen

Für Softwarebasierte Pseudo-Zufallsgenratoren gibt es sehr viele Algorithmen. Je nach Anwendungszweck besitzen diese entweder sehr gute Statistische Eigenschaften oder sind besonders kryptographisch sicher. Es hängt nun davon ab für was du diesen Generator einsetzen möchtest. Z.b. im DEC = Delphi Encryption Compendium findest du eine LFSR = Linear Feedback Shift Register. Dieser ist wesentlich besser als Borland Random, ein LCG. Die LFSR's im DEC haben eine maximale Periode von 2^2038-1 Bits. Random() demgegenüber nur 2^32-1 Bits abhängig vom Seed.

Für kryptographische Anwendungen sind die meisten Generatoren ungeiegnet, da mathematisch berechenbar. In diesem Falle benötigt man keinen zufälligen Output sondern nur einen Output der nicht reproduzierbar ist. Ein gutes Beispiel wäre dafür der Generator YARROW von Bruce Schneier. Als Input bzw. Startwert dienen die Mausbewegungen und Tastenanschläge des Menschens. Dies ist nicht zufällig aber so individuell wie der Mensch selber. D.h. eben nicht reproduzierbar.

Stromverschlüsselungen als solches sind kurz nach dem 2.WK durch die differntielle Kryptoanalyse genackt wurden. Besonders diejenigen Verschlüsselungen die auf Pseudo-Zufallsgeneratoren aufbauten. Aus diesem Wissen heraus wurden die Blockverschlüselungen entwickelt, wie Blowfish, IDEA, Rijndael.

Ich rate dir solche Standardverfahren zu benutzen. Im Delphi Encryption Compendium findest du über 40 der annerkanntesten Verfahren.
Das Wissen was nötig ist einen Verschl. Algo. zu entwickeln ist enorm, sehr trocken, viel Mathematik, Boolsche Algebra, Logische Analyse, Wahrscheinlichkeitsrechnungen und Statistik. In fact die Kryptographie ist die einzigste Disziplin in der Mathematik die direkte praktische Nutzen erzielt.


Gruß hagen

[braingrenade]

Das ist wahrscheinlich das was ich brauche , Wo gibt's sowas ?

[negaH]

Delphi Super Page, VCLComponents, Torry, Delphi JEDI Projekt uvm. Seiten.

[braingrenade]

Ah ja , bei torry hab ich was gefunden !

danke @ all!

[null.L.F.]

ich hab hier noch eine Mersenne Twister Unit

(für leute, die hier über suchen draufkommen (wie ich))

GetFullRangeRandom ist dabei die eigentliche funktion, die einen (pseudo-)zufallszahlenwert zurückliefert
die anderen habe ich lediglich hinzugefügt, um einfach auf andere datentypen zu kommen bzw. der einfachen bedienung wegen.

Delphi-Quellcode:

unit UnitZufall;

(*******************************************************************************)
(**                                                                           **)
(**  TRNGenerator:                                                            **)
(**             Generiert Zufallszahlen nach dem Mersenne Twister.            **)
(**                                                                           **)
(*******************************************************************************)

{$R-} {range checking off}
{$Q-} {overflow checking off}

interface

const rtsRNGN = 624;

type
  TRNGStateArray = array [0..rtsRNGN-1] of Integer; // the array for the state vector

type TRNGenerator = class
  private
    mt : TRNGStateArray;
    mti: Integer;
    // Generiert eine Zufallszahl von Low(Integer) bis High(Integer)
    function GetFullRangeRandom: Integer;
  public
    constructor Create;
    procedure SetSeed(Seed: Integer);                                           overload;
    procedure SetSeed(const SeedArray: TRNGStateArray);                         overload;
    procedure Randomize;
    // Liefert eine Zufallszahl im Bereich von 0 bis +Range zurück:
    function GetRandom(Range: Integer): Integer;                                overload;
    // Liefert eine Zufallszahl im Bereich von 0 bis 1 zurück:
    function GetRandom: Double;                                                 overload;
    // Liefert eine Zufallszahl im Bereich von rFrom bis rTo zurück:
    function GetRandomRange(rFrom, rTo: Integer): Integer;
    // Liefert eine Gauss-Verteilte Zufallszahl zurück:
    function Gauss(Mean, Variance: Extended): Extended;
  end;



implementation

const
{ Period parameters }
  rtsRNGM=397;
  rtsRNGMATRIX_A  =$9908b0df;
  rtsRNGUPPER_MASK=$80000000;
  rtsRNGLOWER_MASK=$7fffffff;
{ Tempering parameters }
  TEMPERING_MASK_B=$9d2c5680;
  TEMPERING_MASK_C=$efc60000;

constructor TRNGenerator.Create;
begin
  mti := rtsRNGN+1;
  inherited;
end;

procedure TRNGenerator.SetSeed(Seed: Integer);
var i: Integer;
begin
  for i := 0 to rtsRNGN-1 do begin
    mt[i]:= seed and $ffff0000;
    seed := 69069 * seed + 1;
    mt[i]:= mt[i] or ((seed and $ffff0000) shr 16);
    seed := 69069 * seed + 1;
  end;
  mti := rtsRNGN;
end;

procedure TRNGenerator.SetSeed(const SeedArray: TRNGStateArray);
var i: Integer;
begin
  for i := 0 to rtsRNGN-1 do
    mt[i] := SeedArray[i];
  mti := rtsRNGN;
end;

function TRNGenerator.GetFullRangeRandom: Integer;
const mag01 : array [0..1] of Integer =(0, rtsRNGMATRIX_A);
var y, kk: Integer;
begin
  if mti >= rtsRNGN then begin
     if mti = (rtsRNGN+1) then SetSeed(4357);
     for kk := 0 to rtsRNGN-rtsRNGM-1 do begin
        y := (mt[kk] and rtsRNGUPPER_MASK) or (mt[kk+1] and rtsRNGLOWER_MASK);
        mt[kk] := mt[kk+rtsRNGM] xor (y shr 1) xor mag01[y and $00000001];
        end;
     for kk:= rtsRNGN-rtsRNGM to rtsRNGN-2 do begin
       y := (mt[kk] and rtsRNGUPPER_MASK) or (mt[kk+1] and rtsRNGLOWER_MASK);
       mt[kk] := mt[kk+(rtsRNGM-rtsRNGN)] xor (y shr 1) xor mag01[y and $00000001];
       end;
     y := (mt[rtsRNGN-1] and rtsRNGUPPER_MASK) or (mt[0] and rtsRNGLOWER_MASK);
     mt[rtsRNGN-1] := mt[rtsRNGM-1] xor (y shr 1) xor mag01[y and $00000001];
     mti := 0;
    end;
  y := mt[mti]; inc(mti);
  y := y xor (y shr 11);
  y := y xor (y shl 7)  and TEMPERING_MASK_B;
  y := y xor (y shl 15) and TEMPERING_MASK_C;
  y := y xor (y shr 18);
  result := y;
end;


procedure TRNGenerator.Randomize;
var alt: Integer;
begin
  alt := System.Randseed;
  System.Randomize;
  SetSeed(System.RandSeed);
  System.RandSeed := alt;
end;

function TRNGenerator.GetRandom(Range: Integer): Integer;
begin
  // 0 <= result < Range
  result := Trunc(Range * GetRandom);
end;

function TRNGenerator.GetRandom: Double;
begin
  result := (Abs(GetFullRangeRandom / High(Integer)))
end;

function TRNGenerator.GetRandomRange(rFrom, rTo: Integer): Integer;
begin
//  rFrom <= result <= rTo
  if rFrom > rTo then result := GetRandom(rFrom - rTo + 1) + rTo
  else result := GetRandom(rTo - rFrom + 1) + rFrom;
end;

function TRNGenerator.Gauss(Mean, Variance: Extended): Extended;
{ Marsaglia-Bray algorithm }
var a, b: Extended;
begin
  repeat
    a := 2 * GetRandom - 1;
    b := Sqr(a) + Sqr(2*GetRandom-1);
  until b < 1;
  result := Sqrt(-2*Ln(b)/b) * a * Variance + Mean;
end;

end.