Schrift
[thread]7822[/thread]

Random generator (Seite 2)

Leser: 1


<< |< 1 2 3 >| >> 25 Einträge, 3 Seiten
Taulmarill
 2006-03-23 14:43
#64019 #64019
User since
2004-02-19
1750 Artikel
BenutzerIn

user image
wenn es dir nur um interne tests geht, dann erstell doch eine datei mit pseudozufallszahlen und lade die vor dem test in einen array.
$_=unpack"B*",~pack"H*",$_ and y&1|0& |#&&print"$_\n"for@.=qw BFA2F7C39139F45F78
0A28104594444504400 0A2F107D54447DE7800 0A2110453444450500 73CF1045138445F4800 0
F3EF2044E3D17DE 8A08A0451412411 F3CF207DF41C79E 820A20451412414 83E93C4513D17D2B
cbxk1xg
 2006-03-23 14:50
#64020 #64020
User since
2003-10-20
496 Artikel
BenutzerIn
[default_avatar]
Könnte man das nicht über eine Art Matheaufgabe lösen? Es geht doch hier nicht um Sicherheit, oder? Dann würde ich einfach Datum und Zeit nehmen und das ganze ein paar Mal multiplizieren, addieren, dividieren, etc. Dann hätte man auch eine "Zufallszahl". Wenn es dir um die Länge geht, dann kannst Du bei zu kurzen Zahlenreihen den Rest noch mit Nullen auffüllen, oder du generierst grundsätzlich längere Zahlen und schneidest den Rest dann einfach ab.
frodus
 2006-03-23 15:34
#64021 #64021
User since
2003-09-26
147 Artikel
BenutzerIn
[default_avatar]
Hi,

das mit dem Array hatte ich mir auch schon überlegt, der haken dabei ist, dass sich die
zufallspattern nicht so schnell widerholen darf. Und in einem TC können bis zu 1-2 Mio.
zufallszahen generiert werden.

Wir haben zur Zeit eine Methode die mir 714025 eindeutige Zufallszahen generiert.
Das hat auch ganz gut funktioniert, leider werden unsere Tests immer grösser und
das fuehrt dazu das sich die Test Daten innerhalb des gleichen Tests wiederholen.
Was das vergleichen der Daten am Schluss des TCs unmöglich macht.

Ich brauche also eine Funktion die mir Zufallszahlen generiert die sich nicht so schnell
wiederholen.

Hier ist mal unsere aktuelle Implementierung:
Code: (dl )
1
2
3
4
5
6
7
8
my $srand_init
sub rand_int
{
my $n = shift();

$srand_init = (($srand_init * 4096) + 150889) % 714025;
return int(($srand_init / 714025) * $n);
}


/Frodus
murphy
 2006-03-23 16:52
#64022 #64022
User since
2004-07-19
1776 Artikel
HausmeisterIn
[Homepage]
user image
Schreibe doch einfach einen einfachen Pseudozufallsgenerator in Perl. Wikipedia:RC4 ist zum Beispiel leicht zu implementieren und wird mit bis zu 256 Bytes Startwert initialisiert.

Der Algorithmus liefert zwar nicht die qualitativ besten Zufallswerte, aber das ist hier wohl auch nicht gefordert, wenn ich das richtig verstanden habe.
When C++ is your hammer, every problem looks like your thumb.
Taulmarill
 2006-03-23 16:53
#64023 #64023
User since
2004-02-19
1750 Artikel
BenutzerIn

user image
hm, also ich hatte jetzt nicht so die probleme, mir eine datei mit 10 Mio. zufallszahlen zu bauen. hier mein ansatz:

rand_pack.pl
Code: (dl )
1
2
3
4
5
6
7
8
use strict;
use warnings;

binmode STDOUT;

for ( 1 .. $ARGV[1] ) {
print pack( "S", int rand( $ARGV[0] ) );
}


rand_unpack.pl
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
use strict;
use warnings;

open( FILE, "<$ARGV[0]" ) or die "$!";

while ( sysread( FILE, $_, 2 ) == 2 ) {
print unpack( "S", $_ );
print "\n";
}

close FILE;


man muss halt nur aufpassen, dass man zum packen einen datentyp nimmt, der maschienenunabhängig ist.
$_=unpack"B*",~pack"H*",$_ and y&1|0& |#&&print"$_\n"for@.=qw BFA2F7C39139F45F78
0A28104594444504400 0A2F107D54447DE7800 0A2110453444450500 73CF1045138445F4800 0
F3EF2044E3D17DE 8A08A0451412411 F3CF207DF41C79E 820A20451412414 83E93C4513D17D2B
frodus
 2006-03-23 17:08
#64024 #64024
User since
2003-09-26
147 Artikel
BenutzerIn
[default_avatar]
Hi,

Danke fuer den link. Werde ich mir mal genauer anschauen.

Das Problem mit der Liste ist, das Du wieder auf den random generator
von perl zugreifst. Und das man immer diese listen kopieren müsste
nachdem sie einmal erstellt worden sind. Dazu muss ich vielleicht erklären, das die TCs auf nahezu unabhängigen Netzten in Europa laufen.

Gruss,

Frodus
esskar
 2006-03-23 21:10
#64025 #64025
User since
2003-08-04
7321 Artikel
ModeratorIn

user image
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/perl

use strict;
use warnings;

use Digest::MD5 ();

sub digest_mix {
   my ($random1) = @_;

   my $ctx = Digest::MD5->new;
   for my $i (0 .. 3) {
       $ctx->add($random1 & 0xff);
       $random1 >>= 8;
   }

   return $ctx->digest;
}

{
   my $_rand = time;
   sub srandom {
       $_rand = shift if @_;
       return $_rand;
   }

   sub random {
       $_rand = unpack("L", digest_mix($_rand));
       return $_rand;
   }
}

srandom(10);
for (1 .. 10) {
   print random(), "\n";
}


funzt ganz gut; ist aber auch nicht wirklich "secure"\n\n

<!--EDIT|esskar|1143143697-->
esskar
 2006-03-23 21:23
#64026 #64026
User since
2003-08-04
7321 Artikel
ModeratorIn

user image
schön ist auch folgender test

Code: (dl )
1
2
3
4
5
6
7
my %seen = ();
$ARGV[0] ? srand(time) : srandom(time);
for (1 .. 10000000) {
my $r = $ARGV[0] ? rand() : random();
die "$_" if exists $seen{$r};
$seen{$r} = 1;
}


somit kann man feststellen, ab wann random wieder von vorne anfängt. rand fängt zwar nicht wieder von vorne an, produziert aber schneller eine kollision.
esskar
 2006-03-23 22:20
#64027 #64027
User since
2003-08-04
7321 Artikel
ModeratorIn

user image
so, jetzt müsstest du genug zahlen erzeugen können, ohne eine kollision zu bekommen

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/perl

use strict;
use warnings;

use Digest ();
use Math::BigInt ();

sub digest_mix {
   my ($random1) = @_;

   my $ctx = Digest->new("SHA-256");
   for my $i (0 .. 31) {
       my $r = $random1->copy;
       my $c = $r->band(0xff);
       $ctx->add($c);
       $random1->brsft(8);
   }

   return $ctx->hexdigest;
}

{
   my $_rand = Math::BigInt->new("0x" . unpack("H*", pack("L", time)));
   sub srandom {
       $_rand = Math::BigInt->new(shift) if @_;
       return $_rand;
   }

   sub random {
       $_rand = Math::BigInt->new("0x" . digest_mix($_rand));
       return $_rand->bstr;
   }
}
\n\n

<!--EDIT|esskar|1143145482-->
ptk
 2006-03-24 00:32
#64028 #64028
User since
2003-11-28
3645 Artikel
ModeratorIn
[default_avatar]
[quote=esskar,23.03.2006, 12:27][quote=renee,23.03.2006, 11:43]und was spricht dagegen, diese Funktionen zu verwenden??[/quote]
sie ist zu leicht durchschaubar. vorallem dann, wenn man den srand wert kennt. kryptographisch gesehen, ist dass ein sicherheitsloch. wenn ich weiß, wie dein srand-wert zum zeitpunkt deiner private-key generierung ist, kann ich mir den selben private-key bauen, unter der voraussetzung, dass dein Private-Key-Generator die rand funktion benutzt.[/quote]
Unter Unix/Linux wird, wenn möglich, /dev/random oder /dev/unrandom verwendet, und das benutzt vom Rechner erzeugte Entropie (Festplattenzugriffe, Tastatureingaben...)
<< |< 1 2 3 >| >> 25 Einträge, 3 Seiten



View all threads created 2006-03-23 12:01.