, forklaring med dephi kilde, der forklarer, hvordan skaber tilfældige numre med passende kilder til entropi og hash funktioner.,, [kryptografiske tilfældige numre], //kildekode brøl, blot at randomize og ved hjælp af random() procedure er en alvorlig brist i sikkerheden påstanden om, at pretect data med tilfældige tal.en nummergeneratoren får er "vilkårlighed fra entropi.borlands random() procedure anvendes en 32bit frø som entropi, og at frø produceres af randomize procedure, som får sin entropi systemet tid og dato, som er meget probabilistisk og kan testes for hurtigt.,,, at generere tilfældige tal, der ikke kan skelnes fra ren kaos er en meget vanskelig opgave på en computer, hovedsagelig fordi du er baseret på interne stater, der ofte er alt for forudsigelig.idéen er at samle entropi fra mindst forudsigelige stater i systemet, og dillute at entropi inde i en meget større pool.pool - jeg henviser til, er den interne situation i nummergeneratoren.,,, hvad det er:,, der er vigtige egenskaber, der skal overholdes, når man skaber tilfældige tal.mere specificaly, tilfældige tal beregnet for kryptering.de egenskaber, der er impliceret i denne tilfældige nummer gerenartors design er kraftigt baseret på bruce schneier er yarrow (www.counterpane. kom).,,, den første ejendom, er at sikre, at der altid er anought entropi i poolen, før outputing tilfældige tal, således at den pool aldrig ind i en svækket tilstand, hvor det næste tilfældige tal, som produktionen er forudsigeligt oplysninger.,,, - - den næste ejendom er nyttig, hvis du skal bruge en generator til sessionsnøgler, der vil ændre sig flere gange i løbet af en chat.det er vigtigt, at en kompromitteret nøgle vil ikke afsløre noget tidligere nøgler eller nogen af de næste nøgler, der vil blive anvendt.for at gøre dette er vi nødt til at fjerne den matematiske forhold mellem de tilfældige tal, som er produktion og staten poolen.,,, det tredje ønskede ejendom, indebærer, at enven hvis entropi indsamlet fra deres kilder er af dårlig kvalitet (temmelig forudsigelige) poolen, ikke må udsættes for lav entropi og output tilfældige tal skal ikke vise tegn på dette.,,, jeg har undersøgt denne enhed i udstrakt grad.det sidste og mest afgørende test, centreret omkring den tredje ejendom.for at gøre et ekstremt tilfælde, jeg startede den pool, kun med nuller i det, og som har skabt - 12mb (100000000 bit).jeg brugte de trofaste prøver (http: //////////////stat.fsu. edu /~ geo /uforbederlige. html), og det gik alle 15 med glans.uden at indsamle entropi.det er jeg tilfreds med nummergeneratoren ydeevne og forelægger det for dig at bruge som et sikkert alternativ til, hvad der er almindeligt i programmer.,,,,, hvordan fungerer det:,,, - to entropi samlere er skabt:,,, [1] er en tråd, der spor mus bevægelighed tilfældigt intervaller under 4bits af entropi fra mus holdning, og systemet er godt ur.,,, [2] en latensperiode regnemaskine, der bliver 4bits af entropi fra højopløsende timer, da kaldt af de vigtigste app (anvendes ved alling,, tkeygenerator.addlatency i tilfælde af en klippe onkeydown rubrik at tælle harddrive reaktionstid eller irq reaktionstid), når enten af entropi samlere har akkumuleret 32bits, det sender det til entropi pool.,,, - entroyp pool, takes i entropi 32bits på et tidspunkt, og bruger det til at fylde en entropi buffer af 256bits, når den buffer er fuld, en primær reseed er henrettet.,,, - den primære reseed ajourfører de primære pool (en hash - sammenhæng: interne stat af en hash - funktion) med entropi og xors med poolen er frø (disse frø, der anvendes på samme måde, som randomize skaber randseed).efter hver primær reseed, frø (med 256bits af entropi) er klar til at blive brugt til produktionen, tilfældige tal, hvis ringe anvendelse, så ønsker det, men det vil fortsat reseed og samle entropi uanset uanset.efter 8 primære reseeds har fundet sted, en sekundær reseed er henrettet.,,, - den sekundære reseed ajourfører de sekundære pool med indholdet af den primære pool og trækker indholdet af den primære pool i en medlemsstat uden entropi.den sekundære pool er persistente i, at det er aldrig færdig og vil bære entropi stykker fra forskellige reseeds.en fuldstændig ny frø, stammer fra den sekundære reseed (som det primære på ændrer det med entropi).det sekundære reseed forhindrer tilbageskridt egenskaber (gessing tidligere stater i poolen, og sikrer, at der er entropi i poolen, selv under forhold, hvor nye entropi er af dårlig kvalitet.,,, - når de kalder anvendelse skal skabe en central kalder safegetkey, som sikrer, at der ikke er mere end 8 sæt 256bits af tilfældige tal kan være som følge af en enkelt reseed.for at gøre dette til et centralt reserve mod øges hver primær reseed, og må ikke overstige 8.når du giver en række tilfældige tal nøglen reserve er decremented og funktion vil vende tilbage fasle, hvis centrale reserve på 0.note: en ansøgning kan ignorere de vigtigste reserve til forcegetkey.det er meget risikabelt praksis og jeg alvorligt afskrække dem fra at anvende denne funktion.,,, - tilfældig produktion som følge af getkey er skabt med entropi pool er frø.frø anvendes som krypteringsnøglen og permuterede (med en ekspansion kompression).den nye frø anvendes som data, der er krypteret.det er krypteret med den foregående frø og udvidet komprimeret i 64 runder.disse runder, sikre, at det er umuligt at bestemme størrelsen af de frø, den primære pool, den sekundære pool eller entorpy buffer igen, forhindrer folk i at finde den tidligere eller kommende resultater.,,,,,,,,, - tildele: en variabel af type tkeygenerator og kalder det. skaber.det vil starte processen.når du er færdig, så ring. destropy.,,, du kan bruge. keycount for at finde ud af den centrale reserve (hvor mange getkey opkald kan foretages, før den næste reseed).jeg bifalder kraftigt, at værdien af max_key_reserve.,,, - - du kan manipulere med den hastighed, hvormed entropi indsamlet fra mus ved at mouse_interval konstant (milli sekunder).en værdi på mindre end 10 unrecommended.,,, - nej fejlkontrol er gjort for at sikre, at der er en høj strid om systemet, bør det kontrolleres af den ringe gennemførelse.hvis der ikke er en sådan modstrid, nummergeneratoren vil arbejde, men vil produktionen ikke - tilfældige tal.,,, - anvendelse skal give 32 bytes hukommelse rum i en variabel til at gå videre med getkey funktioner.ingen fejlkontrol er gjort her.,,, - du kan ændre key_build_rounds til en værdi, der er større end eller lig med 32, men større end 64 er helt uduelig.,,,,,,, *********************************************************************, og /*********************************************************************, - bemærk -,,, kilden arbejde er en del af et bibliotek i fremskridt cummulating 3 år af min forskning.hvis du ønsker at bruge det i et program, en lille smule kredit ville være rart.,,, nscrypt.pas indeholder en pseudo - nummergeneratoren, der kommer fra en ukendt kilde, og disse anvendelser af haval og rijndael [alvorlige] ændringer af david barton er haval.pas og rijndael.pas fandt i dcpcrypt 1.3 komponent suite.,, downloade nscrypt.txt og omdøbe det nscrypt.pas (fjollet webhost) jeg har medtaget den kryptografiske funktioner sepperatly, fordi de samlede 1300 replikker sammen.,,http: //////////////////////www.eccentrix. kom - drmungkee /nscrypt. txt, (den faktiske websted er www.drmungkee. kom), og /********************************************************************* /*********************************************************************,,, vil du, //er nødt til at beskæftige sig med dokumentation over.,,, enhed noisespunge,,,,,,,,, bruger grænseflade, vinduer, klasser, kontrol, nscrypt; denne,,,,,,,, seed_size = 8;,, primary_reseed = seed_size;,, secondary_reseed = seed_size;,,, //parametre, max_key_reserve = 8;,, key_build_rounds = 64;,, mouse_interval = 10,,,,,,,,, key256 = system [0 - seed_size-1] af longword;,,, tnoisespungeaddentropy = procedure (blok: longword) af objekt,,, tnoisespungeprocedure = procedure af objekt,,,,,,, tmousecollector = klasse (tthread), beskyttet,, pctx: prng_ctx;,, x, y: heltal, blokere: longword;,, bitsgathered: longword;, interval, hyppighed, nu, lasttime: tlargeinteger;,, sendmouseentropy: tnoisespungeaddentropy;, offentlig, konstruktøren skabe;,, procedure syncsendmouseentropy;,, procedure henrette; gearvalg;,,,,,,,,, tlatencycollector = klasse, beskyttet, blok: longword;,, bitsgathered: longword;,,: tlargeinteger;,, sendlatencyentropy: tnoisespungeaddentropy,,,,, konstruktøren skabe;,, procedure measurelatency,,,,,,, tentropypool = klasse, beskyttet, frø: key256;,, entropybuffer: key256;,, primarypool: haval_ctx;,, secondarypool: haval_ctx;,, primaryreseedcount: byte;,, entropycount: byte;,, keyreserve: byte. procedure permuteseed;,, procedure primaryreseed;,, procedure secondaryreseed,,,procedure addentropy (rubrik: longword), offentlig, konstruktøren skabe,,,,,,, tkeygenerator = klasse, beskyttet, entropypool: tentropypool;,, mousecollector: tmousecollector;,, latencycollector: tlatencycollector;, offentlig, addlatency: tnoisespungeprocedure,,,,, - ødelægger konstruktøren skabe. ødelægge; gearvalg;,, funktion keycount: byte;,, funktion safegetkey (var - nøgle): boolean,,, procedure forcedgetkey (var - nøgle);,,,,,,,,,, - gennemførelse, konstruktøren tmousecollector. skabe;, begynder, har skabe (korrekt), randomize;,, prnginit (@ pctx, randseed);,, freeonterminate: = sandt;,, prioritet: = tpnormal;,, genoptage,,,.,,, procedure tmousecollector. syncsendmouseentropy;,, begynder, sendmouseentropy (blok),,,,,,, procedure tmousecollector. udføre;,, var nilhandle: pointer,,, idled: boolean,,, begynder, nilhandle: = 0,,, bitsgathered: = 0,,, idled: = falske,, queryperformancefrequency (hyppighed), som, jeg gentager, hvis idled = falske så, begynder, msgwaitformultipleobjects (0, nilhandle, falske mouse_interval, 0), idled: = sandt,,,,,, queryperformancecounter (nu), hvis denne gang lasttime > interval, begynder, hvis (x < > mus. cursorpos. x og y < > mus. cursorpos. y), begynder, x = mus. cursorpos. x, y,: = mus. cursorpos. y,,, -nc (blok, (((x) og 15) xor (y og 15) xor (nu og 15) sømhaj shb,, bitsgathered);,, inc. (bitsgathered, 4), hvis bitsgathered = 32, begynder, prnginit (@ pctx, block);,, synkronisere (syncsendmouseentropy);,, blok: = 0, bitsgathered: = 0,,,,,, - interval: = ((((prng (@ pctx) mod mouse_interval) div. 2 + mouse_interval), * hyppighed) div. 1000;,, queryperformancecounter (lasttime);,, idled: = falsk,,,,, begynder, queryperformancecounter (lasttime);,, idled: = falske,,,,,,,,,, indtil den opsiges = sandt,,,,,,,,,, konstruktøren tLatencyCollector.Create;,, begin,, inherited Create;,, Block:=0;,, BitsGathered:=0;,, end;,,, procedure TLatencyCollector.MeasureLatency;,, begin,, QueryPerformanceCounter(Time);,, Inc(Block,(Time and 15)shl BitsGathered);,, Inc(BitsGathered,4);,, if BitsGathered=32 then,, begin,, SendLatencyEntropy(Block);,, Block:=0;,, BitsGathered:=0;,, end;,, end;,,, constructor TEntropyPool.Create;,, begin,, inherited Create;,, HavalInit(@PrimaryPool);,, HavalInit(@SecondaryPool);,, FillChar(Seed,SizeOf(Seed),0);,, EntropyCount:=0;,, PrimaryReseedCount:=0;,, KeyReserve:=0;,, end;,,, procedure TEntropyPool.PermuteSeed;,, var TempBuffer:array[0..1]of Key256;,, PCtx:Prng_CTX;,, HCtx:Haval_CTX;,, i:byte;,, begin,, for i:=0 to SEED_SIZE-1 do,, begin,, PrngInit(@PCtx,Seed[i]);,, TempBuffer[0,i]:=Prng(@PCtx);,, TempBuffer[1,i]:=Prng(@PCtx);,, end;,, HavalInit(@HCtx);,, HavalUpdate(@HCtx,TempBuffer,SizeOf(TempBuffer));,, HavalOutput(@HCtx,Seed);,, end;,,, procedure TEntropyPool.PrimaryReseed;,, var TempSeed:Key256;,, i:byte;,, begin,, HavalUpdate(@PrimaryPool,EntropyBuffer,SizeOf(EntropyBuffer));,, if PrimaryReseedCount, begin,, HavalOutput(@PrimaryPool,TempSeed);,, for i:=0 to SEED_SIZE-1 do Seed[i]:=Seed[i] xor TempSeed[i];,, Inc(PrimaryReseedCount);,, end else SecondaryReseed;,, FillChar(EntropyBuffer,SizeOf(EntropyBuffer),0);,, if KeyRese6, entropycount: = 0,,,,,,, procedure tentropypool. secondaryreseed;,, begynder, havaloutput (@ primarypool, frø), havalupdate (@ secondarypool, frø, 7 (frø), havaloutput (@ secondarypool, frø), permuteseed;,, havalinit (@ primarypool);,, primaryreseedcount: = 0,,,,,,, procedure tentropypool. addentropy (rubrik: longword), begynder, så (blok, point (longword (@ entropybuffer) + (entropycount * 7 (block)), 7 (blok),, he runde (entropycount, 1), hvis entropycount = primary_reseed så primaryreseed,,,,,,, konstruktøren tkeygenerator. skabe;, begynder, har skabt,,, entropypool: = tentropypool. skabe;,, mousecollector: = tmousecollector. skabe;,, mousecollector. sendmouseentropy: = entropypool.addentropy;,, latencycollector: = tlatencycollector. skabe;,, latencycollector. sendlatencyentropy: = entropypool. addentropy;,, addlatency: = latencycollector. measurelatency,,,,,,, tkeygenerator destructor. ødelægge;,, begynder, mousecollector. afslutte;,, latencycollector. ødelægge,,, entropypool. ødelægge.,, arvede ødelægge,,,,,,, funktion tkeygenerator. keycount: byte;,, begynder, resultat: = entropypool. keyreserve,,,,,,, funktion tkeygenerator. safegetkey (var - nøgle): boolean,,, var tempseed: key256;,, tempbuffer: system [0.. 1) i key256;,, rctx: rijndael_ctx;,, pctx: prng_ctx;,, hctx: haval_ctx,,, jeg, j: byte;, begynder, hvis entropypool. keyreserve = 0, begynder, udpassage, resultat: = falske, i slutningen af andet result:=true;,, Move(EntropyPool.Seed,TempSeed,SizeOf(TempSeed));,, EntropyPool.PermuteSeed;,, RijndaelInit(@RCtx,EntropyPool.Seed);,, for i:=0 to KEY_BUILD_ROUNDS-1 do,, begin,, RijndaelEncrypt(@RCtx,TempSeed[0]);,, RijndaelEncrypt(@RCtx,TempSeed[4]);,, for j:=0 to SEED_SIZE-1 do,, begin,, PrngInit(@pctx,TempSeed[j]);,, TempBuffer[0,j]:=Prng(@PCtx);,, TempBuffer[1,j]:=Prng(@PCtx);,, end;,, HavalInit(@HCtx);,, HavalUpdate(@HCtx,TempBuffer,SizeOf(TempBuffer));,, HavalOutput(@HCtx,TempSeed);,, end;,, Move(TempSeed,Key,SizeOf(TempSeed));,, Dec(EntropyPool.KeyReserve,1);,, end;,,, procedure TKeyGenerator.ForcedGetKey(var Key);,, var TempSeed:Key256;,, TempBuffer:array[0..1]of Key256;,, RCtx:Rijndael_CTX;,, PCtx:Prng_CTX;,, HCtx:Haval_CTX;,, i,j:byte;,, begin,, Move(EntropyPool.Seed,TempSeed,SizeOf(TempSeed));,, EntropyPool.PermuteSeed;,, RijndaelInit(@RCtx,EntropyPool.Seed);,, for i:=0 to KEY_BUILD_ROUNDS-1 do,, begin,, RijndaelEncrypt(@RCtx,TempSeed[0]);,, RijndaelEncrypt(@RCtx,TempSeed[4]);,, for j:=0 to SEED_SIZE-1 do,, begin,, PrngInit(@pctx,TempSeed[j]);,, TempBuffer[0,j]:=Prng(@PCtx);,, TempBuffer[1,j]:=Prng(@PCtx);,, end;,, HavalInit(@HCtx);,, HavalUpdate(@HCtx,TempBuffer,SizeOf(TempBuffer));,, HavalOutput(@HCtx,TempSeed);,, end;,, Move(TempSeed,Key,SizeOf(TempSeed), hvis entropypool. keyreserve < 0 - dec (entropypool. keyreserve, 1),,,,,,,.,,, (c) ophavsret drmungkee, 2001 (www.drmungkee.com, drmungkee @ hotmail. kom),